// jskelly uses mootools
// version: 0.96 [duze zdjecia,efekt do opisu]
// created by kello www.kello.pl/soft/jskelly
// last update: 19.03.2008

//MooTools, My Object Oriented Javascript Tools. Copyright (c) 2006-2007 Valerio Proietti, <http://mad4milk.net>, MIT Style License.

var MooTools = {
	version: '1.11'
};

function $defined(obj){
	return (obj != undefined);
};

function $type(obj){
	if (!$defined(obj)) return false;
	if (obj.htmlElement) return 'element';
	var type = typeof obj;
	if (type == 'object' && obj.nodeName){
		switch(obj.nodeType){
			case 1: return 'element';
			case 3: return (/\S/).test(obj.nodeValue) ? 'textnode' : 'whitespace';
		}
	}
	if (type == 'object' || type == 'function'){
		switch(obj.constructor){
			case Array: return 'array';
			case RegExp: return 'regexp';
			case Class: return 'class';
		}
		if (typeof obj.length == 'number'){
			if (obj.item) return 'collection';
			if (obj.callee) return 'arguments';
		}
	}
	return type;
};

function $merge(){
	var mix = {};
	for (var i = 0; i < arguments.length; i++){
		for (var property in arguments[i]){
			var ap = arguments[i][property];
			var mp = mix[property];
			if (mp && $type(ap) == 'object' && $type(mp) == 'object') mix[property] = $merge(mp, ap);
			else mix[property] = ap;
		}
	}
	return mix;
};

var $extend = function(){
	var args = arguments;
	if (!args[1]) args = [this, args[0]];
	for (var property in args[1]) args[0][property] = args[1][property];
	return args[0];
};

var $native = function(){
	for (var i = 0, l = arguments.length; i < l; i++){
		arguments[i].extend = function(props){
			for (var prop in props){
				if (!this.prototype[prop]) this.prototype[prop] = props[prop];
				if (!this[prop]) this[prop] = $native.generic(prop);
			}
		};
	}
};

$native.generic = function(prop){
	return function(bind){
		return this.prototype[prop].apply(bind, Array.prototype.slice.call(arguments, 1));
	};
};

$native(Function, Array, String, Number);

function $chk(obj){
	return !!(obj || obj === 0);
};

function $pick(obj, picked){
	return $defined(obj) ? obj : picked;
};

function $random(min, max){
	return Math.floor(Math.random() * (max - min + 1) + min);
};

function $time(){
	return new Date().getTime();
};

function $clear(timer){
	clearTimeout(timer);
	clearInterval(timer);
	return null;
};

var Abstract = function(obj){
	obj = obj || {};
	obj.extend = $extend;
	return obj;
};

var Window = new Abstract(window);
var Document = new Abstract(document);
document.head = document.getElementsByTagName('head')[0];

window.xpath = !!(document.evaluate);
if (window.ActiveXObject) window.ie = window[window.XMLHttpRequest ? 'ie7' : 'ie6'] = true;
else if (document.childNodes && !document.all && !navigator.taintEnabled) window.webkit = window[window.xpath ? 'webkit420' : 'webkit419'] = true;
else if (document.getBoxObjectFor != null) window.gecko = true;

window.khtml = window.webkit;

Object.extend = $extend;

if (typeof HTMLElement == 'undefined'){
	var HTMLElement = function(){};
	if (window.webkit) document.createElement("iframe");
	HTMLElement.prototype = (window.webkit) ? window["[[DOMElement.prototype]]"] : {};
}
HTMLElement.prototype.htmlElement = function(){};

if (window.ie6) try {document.execCommand("BackgroundImageCache", false, true);} catch(e){};

var Class = function(properties){
	var klass = function(){
		return (arguments[0] !== null && this.initialize && $type(this.initialize) == 'function') ? this.initialize.apply(this, arguments) : this;
	};
	$extend(klass, this);
	klass.prototype = properties;
	klass.constructor = Class;
	return klass;
};

Class.empty = function(){};

Class.prototype = {

	extend: function(properties){
		var proto = new this(null);
		for (var property in properties){
			var pp = proto[property];
			proto[property] = Class.Merge(pp, properties[property]);
		}
		return new Class(proto);
	},

	implement: function(){
		for (var i = 0, l = arguments.length; i < l; i++) $extend(this.prototype, arguments[i]);
	}

};

Class.Merge = function(previous, current){
	if (previous && previous != current){
		var type = $type(current);
		if (type != $type(previous)) return current;
		switch(type){
			case 'function':
				var merged = function(){
					this.parent = arguments.callee.parent;
					return current.apply(this, arguments);
				};
				merged.parent = previous;
				return merged;
			case 'object': return $merge(previous, current);
		}
	}
	return current;
};

var Chain = new Class({

	chain: function(fn){
		this.chains = this.chains || [];
		this.chains.push(fn);
		return this;
	},

	callChain: function(){
		if (this.chains && this.chains.length) this.chains.shift().delay(10, this);
	},

	clearChain: function(){
		this.chains = [];
	}

});

var Events = new Class({

	addEvent: function(type, fn){
		if (fn != Class.empty){
			this.$events = this.$events || {};
			this.$events[type] = this.$events[type] || [];
			this.$events[type].include(fn);
		}
		return this;
	},

	fireEvent: function(type, args, delay){
		if (this.$events && this.$events[type]){
			this.$events[type].each(function(fn){
				fn.create({'bind': this, 'delay': delay, 'arguments': args})();
			}, this);
		}
		return this;
	},

	removeEvent: function(type, fn){
		if (this.$events && this.$events[type]) this.$events[type].remove(fn);
		return this;
	}

});

var Options = new Class({

	setOptions: function(){
		this.options = $merge.apply(null, [this.options].extend(arguments));
		if (this.addEvent){
			for (var option in this.options){
				if ($type(this.options[option] == 'function') && (/^on[A-Z]/).test(option)) this.addEvent(option, this.options[option]);
			}
		}
		return this;
	}

});

Array.extend({

	forEach: function(fn, bind){
		for (var i = 0, j = this.length; i < j; i++) fn.call(bind, this[i], i, this);
	},

	filter: function(fn, bind){
		var results = [];
		for (var i = 0, j = this.length; i < j; i++){
			if (fn.call(bind, this[i], i, this)) results.push(this[i]);
		}
		return results;
	},

	map: function(fn, bind){
		var results = [];
		for (var i = 0, j = this.length; i < j; i++) results[i] = fn.call(bind, this[i], i, this);
		return results;
	},

	every: function(fn, bind){
		for (var i = 0, j = this.length; i < j; i++){
			if (!fn.call(bind, this[i], i, this)) return false;
		}
		return true;
	},

	some: function(fn, bind){
		for (var i = 0, j = this.length; i < j; i++){
			if (fn.call(bind, this[i], i, this)) return true;
		}
		return false;
	},

	indexOf: function(item, from){
		var len = this.length;
		for (var i = (from < 0) ? Math.max(0, len + from) : from || 0; i < len; i++){
			if (this[i] === item) return i;
		}
		return -1;
	},

	copy: function(start, length){
		start = start || 0;
		if (start < 0) start = this.length + start;
		length = length || (this.length - start);
		var newArray = [];
		for (var i = 0; i < length; i++) newArray[i] = this[start++];
		return newArray;
	},

	remove: function(item){
		var i = 0;
		var len = this.length;
		while (i < len){
			if (this[i] === item){
				this.splice(i, 1);
				len--;
			} else {
				i++;
			}
		}
		return this;
	},

	contains: function(item, from){
		return this.indexOf(item, from) != -1;
	},

	associate: function(keys){
		var obj = {}, length = Math.min(this.length, keys.length);
		for (var i = 0; i < length; i++) obj[keys[i]] = this[i];
		return obj;
	},

	extend: function(array){
		for (var i = 0, j = array.length; i < j; i++) this.push(array[i]);
		return this;
	},

	merge: function(array){
		for (var i = 0, l = array.length; i < l; i++) this.include(array[i]);
		return this;
	},

	include: function(item){
		if (!this.contains(item)) this.push(item);
		return this;
	},

	getRandom: function(){
		return this[$random(0, this.length - 1)] || null;
	},

	getLast: function(){
		return this[this.length - 1] || null;
	}

});

Array.prototype.each = Array.prototype.forEach;
Array.each = Array.forEach;

function $A(array){
	return Array.copy(array);
};

function $each(iterable, fn, bind){
	if (iterable && typeof iterable.length == 'number' && $type(iterable) != 'object'){
		Array.forEach(iterable, fn, bind);
	} else {
		 for (var name in iterable) fn.call(bind || iterable, iterable[name], name);
	}
};

Array.prototype.test = Array.prototype.contains;

String.extend({

	test: function(regex, params){
		return (($type(regex) == 'string') ? new RegExp(regex, params) : regex).test(this);
	},

	toInt: function(){
		return parseInt(this, 10);
	},

	toFloat: function(){
		return parseFloat(this);
	},

	camelCase: function(){
		return this.replace(/-\D/g, function(match){
			return match.charAt(1).toUpperCase();
		});
	},

	hyphenate: function(){
		return this.replace(/\w[A-Z]/g, function(match){
			return (match.charAt(0) + '-' + match.charAt(1).toLowerCase());
		});
	},

	capitalize: function(){
		return this.replace(/\b[a-z]/g, function(match){
			return match.toUpperCase();
		});
	},

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

	clean: function(){
		return this.replace(/\s{2,}/g, ' ').trim();
	},

	rgbToHex: function(array){
		var rgb = this.match(/\d{1,3}/g);
		return (rgb) ? rgb.rgbToHex(array) : false;
	},

	hexToRgb: function(array){
		var hex = this.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
		return (hex) ? hex.slice(1).hexToRgb(array) : false;
	},

	contains: function(string, s){
		return (s) ? (s + this + s).indexOf(s + string + s) > -1 : this.indexOf(string) > -1;
	},

	escapeRegExp: function(){
		return this.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
	}

});

Array.extend({

	rgbToHex: function(array){
		if (this.length < 3) return false;
		if (this.length == 4 && this[3] == 0 && !array) return 'transparent';
		var hex = [];
		for (var i = 0; i < 3; i++){
			var bit = (this[i] - 0).toString(16);
			hex.push((bit.length == 1) ? '0' + bit : bit);
		}
		return array ? hex : '#' + hex.join('');
	},

	hexToRgb: function(array){
		if (this.length != 3) return false;
		var rgb = [];
		for (var i = 0; i < 3; i++){
			rgb.push(parseInt((this[i].length == 1) ? this[i] + this[i] : this[i], 16));
		}
		return array ? rgb : 'rgb(' + rgb.join(',') + ')';
	}

});

Function.extend({

	create: function(options){
		var fn = this;
		options = $merge({
			'bind': fn,
			'event': false,
			'arguments': null,
			'delay': false,
			'periodical': false,
			'attempt': false
		}, options);
		if ($chk(options.arguments) && $type(options.arguments) != 'array') options.arguments = [options.arguments];
		return function(event){
			var args;
			if (options.event){
				event = event || window.event;
				args = [(options.event === true) ? event : new options.event(event)];
				if (options.arguments) args.extend(options.arguments);
			}
			else args = options.arguments || arguments;
			var returns = function(){
				return fn.apply($pick(options.bind, fn), args);
			};
			if (options.delay) return setTimeout(returns, options.delay);
			if (options.periodical) return setInterval(returns, options.periodical);
			if (options.attempt) try {return returns();} catch(err){return false;};
			return returns();
		};
	},

	pass: function(args, bind){
		return this.create({'arguments': args, 'bind': bind});
	},

	attempt: function(args, bind){
		return this.create({'arguments': args, 'bind': bind, 'attempt': true})();
	},

	bind: function(bind, args){
		return this.create({'bind': bind, 'arguments': args});
	},

	bindAsEventListener: function(bind, args){
		return this.create({'bind': bind, 'event': true, 'arguments': args});
	},

	delay: function(delay, bind, args){
		return this.create({'delay': delay, 'bind': bind, 'arguments': args})();
	},

	periodical: function(interval, bind, args){
		return this.create({'periodical': interval, 'bind': bind, 'arguments': args})();
	}

});

Number.extend({

	toInt: function(){
		return parseInt(this);
	},

	toFloat: function(){
		return parseFloat(this);
	},

	limit: function(min, max){
		return Math.min(max, Math.max(min, this));
	},

	round: function(precision){
		precision = Math.pow(10, precision || 0);
		return Math.round(this * precision) / precision;
	},

	times: function(fn){
		for (var i = 0; i < this; i++) fn(i);
	}

});

var Element = new Class({

	initialize: function(el, props){
		if ($type(el) == 'string'){
			if (window.ie && props && (props.name || props.type)){
				var name = (props.name) ? ' name="' + props.name + '"' : '';
				var type = (props.type) ? ' type="' + props.type + '"' : '';
				delete props.name;
				delete props.type;
				el = '<' + el + name + type + '>';
			}
			el = document.createElement(el);
		}
		el = $(el);
		return (!props || !el) ? el : el.set(props);
	}

});

var Elements = new Class({

	initialize: function(elements){
		return (elements) ? $extend(elements, this) : this;
	}

});

Elements.extend = function(props){
	for (var prop in props){
		this.prototype[prop] = props[prop];
		this[prop] = $native.generic(prop);
	}
};

function $(el){
	if (!el) return null;
	if (el.htmlElement) return Garbage.collect(el);
	if ([window, document].contains(el)) return el;
	var type = $type(el);
	if (type == 'string'){
		el = document.getElementById(el);
		type = (el) ? 'element' : false;
	}
	if (type != 'element') return null;
	if (el.htmlElement) return Garbage.collect(el);
	if (['object', 'embed'].contains(el.tagName.toLowerCase())) return el;
	$extend(el, Element.prototype);
	el.htmlElement = function(){};
	return Garbage.collect(el);
};

document.getElementsBySelector = document.getElementsByTagName;

function $$(){
	var elements = [];
	for (var i = 0, j = arguments.length; i < j; i++){
		var selector = arguments[i];
		switch($type(selector)){
			case 'element': elements.push(selector);
			case 'boolean': break;
			case false: break;
			case 'string': selector = document.getElementsBySelector(selector, true);
			default: elements.extend(selector);
		}
	}
	return $$.unique(elements);
};

$$.unique = function(array){
	var elements = [];
	for (var i = 0, l = array.length; i < l; i++){
		if (array[i].$included) continue;
		var element = $(array[i]);
		if (element && !element.$included){
			element.$included = true;
			elements.push(element);
		}
	}
	for (var n = 0, d = elements.length; n < d; n++) elements[n].$included = null;
	return new Elements(elements);
};

Elements.Multi = function(property){
	return function(){
		var args = arguments;
		var items = [];
		var elements = true;
		for (var i = 0, j = this.length, returns; i < j; i++){
			returns = this[i][property].apply(this[i], args);
			if ($type(returns) != 'element') elements = false;
			items.push(returns);
		};
		return (elements) ? $$.unique(items) : items;
	};
};

Element.extend = function(properties){
	for (var property in properties){
		HTMLElement.prototype[property] = properties[property];
		Element.prototype[property] = properties[property];
		Element[property] = $native.generic(property);
		var elementsProperty = (Array.prototype[property]) ? property + 'Elements' : property;
		Elements.prototype[elementsProperty] = Elements.Multi(property);
	}
};

Element.extend({

	set: function(props){
		for (var prop in props){
			var val = props[prop];
			switch(prop){
				case 'styles': this.setStyles(val); break;
				case 'events': if (this.addEvents) this.addEvents(val); break;
				case 'properties': this.setProperties(val); break;
				default: this.setProperty(prop, val);
			}
		}
		return this;
	},

	inject: function(el, where){
		el = $(el);
		switch(where){
			case 'before': el.parentNode.insertBefore(this, el); break;
			case 'after':
				var next = el.getNext();
				if (!next) el.parentNode.appendChild(this);
				else el.parentNode.insertBefore(this, next);
				break;
			case 'top':
				var first = el.firstChild;
				if (first){
					el.insertBefore(this, first);
					break;
				}
			default: el.appendChild(this);
		}
		return this;
	},

	injectBefore: function(el){
		return this.inject(el, 'before');
	},

	injectAfter: function(el){
		return this.inject(el, 'after');
	},

	injectInside: function(el){
		return this.inject(el, 'bottom');
	},

	injectTop: function(el){
		return this.inject(el, 'top');
	},

	adopt: function(){
		var elements = [];
		$each(arguments, function(argument){
			elements = elements.concat(argument);
		});
		$$(elements).inject(this);
		return this;
	},

	remove: function(){
		return this.parentNode.removeChild(this);
	},

	clone: function(contents){
		var el = $(this.cloneNode(contents !== false));
		if (!el.$events) return el;
		el.$events = {};
		for (var type in this.$events) el.$events[type] = {
			'keys': $A(this.$events[type].keys),
			'values': $A(this.$events[type].values)
		};
		return el.removeEvents();
	},

	replaceWith: function(el){
		el = $(el);
		this.parentNode.replaceChild(el, this);
		return el;
	},

	appendText: function(text){
		this.appendChild(document.createTextNode(text));
		return this;
	},

	hasClass: function(className){
		return this.className.contains(className, ' ');
	},

	addClass: function(className){
		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
		return this;
	},

	removeClass: function(className){
		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1').clean();
		return this;
	},

	toggleClass: function(className){
		return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
	},

	setStyle: function(property, value){
		switch(property){
			case 'opacity': return this.setOpacity(parseFloat(value));
			case 'float': property = (window.ie) ? 'styleFloat' : 'cssFloat';
		}
		property = property.camelCase();
		switch($type(value)){
			case 'number': if (!['zIndex', 'zoom'].contains(property)) value += 'px'; break;
			case 'array': value = 'rgb(' + value.join(',') + ')';
		}
		this.style[property] = value;
		return this;
	},

	setStyles: function(source){
		switch($type(source)){
			case 'object': Element.setMany(this, 'setStyle', source); break;
			case 'string': this.style.cssText = source;
		}
		return this;
	},

	setOpacity: function(opacity){
		if (opacity == 0){
			if (this.style.visibility != "hidden") this.style.visibility = "hidden";
		} else {
			if (this.style.visibility != "visible") this.style.visibility = "visible";
		}
		if (!this.currentStyle || !this.currentStyle.hasLayout) this.style.zoom = 1;
		if (window.ie) this.style.filter = (opacity == 1) ? '' : "alpha(opacity=" + opacity * 100 + ")";
		this.style.opacity = this.$tmp.opacity = opacity;
		return this;
	},

	getStyle: function(property){
		property = property.camelCase();
		var result = this.style[property];
		if (!$chk(result)){
			if (property == 'opacity') return this.$tmp.opacity;
			result = [];
			for (var style in Element.Styles){
				if (property == style){
					Element.Styles[style].each(function(s){
						var style = this.getStyle(s);
						result.push(parseInt(style) ? style : '0px');
					}, this);
					if (property == 'border'){
						var every = result.every(function(bit){
							return (bit == result[0]);
						});
						return (every) ? result[0] : false;
					}
					return result.join(' ');
				}
			}
			if (property.contains('border')){
				if (Element.Styles.border.contains(property)){
					return ['Width', 'Style', 'Color'].map(function(p){
						return this.getStyle(property + p);
					}, this).join(' ');
				} else if (Element.borderShort.contains(property)){
					return ['Top', 'Right', 'Bottom', 'Left'].map(function(p){
						return this.getStyle('border' + p + property.replace('border', ''));
					}, this).join(' ');
				}
			}
			if (document.defaultView) result = document.defaultView.getComputedStyle(this, null).getPropertyValue(property.hyphenate());
			else if (this.currentStyle) result = this.currentStyle[property];
		}
		if (window.ie) result = Element.fixStyle(property, result, this);
		if (result && property.test(/color/i) && result.contains('rgb')){
			return result.split('rgb').splice(1,4).map(function(color){
				return color.rgbToHex();
			}).join(' ');
		}
		return result;
	},

	getStyles: function(){
		return Element.getMany(this, 'getStyle', arguments);
	},

	walk: function(brother, start){
		brother += 'Sibling';
		var el = (start) ? this[start] : this[brother];
		while (el && $type(el) != 'element') el = el[brother];
		return $(el);
	},

	getPrevious: function(){
		return this.walk('previous');
	},

	getNext: function(){
		return this.walk('next');
	},

	getFirst: function(){
		return this.walk('next', 'firstChild');
	},

	getLast: function(){
		return this.walk('previous', 'lastChild');
	},

	getParent: function(){
		return $(this.parentNode);
	},

	getChildren: function(){
		return $$(this.childNodes);
	},

	hasChild: function(el){
		return !!$A(this.getElementsByTagName('*')).contains(el);
	},

	getProperty: function(property){
		var index = Element.Properties[property];
		if (index) return this[index];
		var flag = Element.PropertiesIFlag[property] || 0;
		if (!window.ie || flag) return this.getAttribute(property, flag);
		var node = this.attributes[property];
		return (node) ? node.nodeValue : null;
	},

	removeProperty: function(property){
		var index = Element.Properties[property];
		if (index) this[index] = '';
		else this.removeAttribute(property);
		return this;
	},

	getProperties: function(){
		return Element.getMany(this, 'getProperty', arguments);
	},

	setProperty: function(property, value){
		var index = Element.Properties[property];
		if (index) this[index] = value;
		else this.setAttribute(property, value);
		return this;
	},

	setProperties: function(source){
		return Element.setMany(this, 'setProperty', source);
	},

	setHTML: function(){
		this.innerHTML = $A(arguments).join('');
		return this;
	},

	setText: function(text){
		var tag = this.getTag();
		if (['style', 'script'].contains(tag)){
			if (window.ie){
				if (tag == 'style') this.styleSheet.cssText = text;
				else if (tag ==  'script') this.setProperty('text', text);
				return this;
			} else {
				this.removeChild(this.firstChild);
				return this.appendText(text);
			}
		}
		this[$defined(this.innerText) ? 'innerText' : 'textContent'] = text;
		return this;
	},

	getText: function(){
		var tag = this.getTag();
		if (['style', 'script'].contains(tag)){
			if (window.ie){
				if (tag == 'style') return this.styleSheet.cssText;
				else if (tag ==  'script') return this.getProperty('text');
			} else {
				return this.innerHTML;
			}
		}
		return ($pick(this.innerText, this.textContent));
	},

	getTag: function(){
		return this.tagName.toLowerCase();
	},

	empty: function(){
		Garbage.trash(this.getElementsByTagName('*'));
		return this.setHTML('');
	}

});

Element.fixStyle = function(property, result, element){
	if ($chk(parseInt(result))) return result;
	if (['height', 'width'].contains(property)){
		var values = (property == 'width') ? ['left', 'right'] : ['top', 'bottom'];
		var size = 0;
		values.each(function(value){
			size += element.getStyle('border-' + value + '-width').toInt() + element.getStyle('padding-' + value).toInt();
		});
		return element['offset' + property.capitalize()] - size + 'px';
	} else if (property.test(/border(.+)Width|margin|padding/)){
		return '0px';
	}
	return result;
};

Element.Styles = {'border': [], 'padding': [], 'margin': []};
['Top', 'Right', 'Bottom', 'Left'].each(function(direction){
	for (var style in Element.Styles) Element.Styles[style].push(style + direction);
});

Element.borderShort = ['borderWidth', 'borderStyle', 'borderColor'];

Element.getMany = function(el, method, keys){
	var result = {};
	$each(keys, function(key){
		result[key] = el[method](key);
	});
	return result;
};

Element.setMany = function(el, method, pairs){
	for (var key in pairs) el[method](key, pairs[key]);
	return el;
};

Element.Properties = new Abstract({
	'class': 'className', 'for': 'htmlFor', 'colspan': 'colSpan', 'rowspan': 'rowSpan',
	'accesskey': 'accessKey', 'tabindex': 'tabIndex', 'maxlength': 'maxLength',
	'readonly': 'readOnly', 'frameborder': 'frameBorder', 'value': 'value',
	'disabled': 'disabled', 'checked': 'checked', 'multiple': 'multiple', 'selected': 'selected'
});
Element.PropertiesIFlag = {
	'href': 2, 'src': 2
};

Element.Methods = {
	Listeners: {
		addListener: function(type, fn){
			if (this.addEventListener) this.addEventListener(type, fn, false);
			else this.attachEvent('on' + type, fn);
			return this;
		},

		removeListener: function(type, fn){
			if (this.removeEventListener) this.removeEventListener(type, fn, false);
			else this.detachEvent('on' + type, fn);
			return this;
		}
	}
};

window.extend(Element.Methods.Listeners);
document.extend(Element.Methods.Listeners);
Element.extend(Element.Methods.Listeners);

var Garbage = {

	elements: [],

	collect: function(el){
		if (!el.$tmp){
			Garbage.elements.push(el);
			el.$tmp = {'opacity': 1};
		}
		return el;
	},

	trash: function(elements){
		for (var i = 0, j = elements.length, el; i < j; i++){
			if (!(el = elements[i]) || !el.$tmp) continue;
			if (el.$events) el.fireEvent('trash').removeEvents();
			for (var p in el.$tmp) el.$tmp[p] = null;
			for (var d in Element.prototype) el[d] = null;
			Garbage.elements[Garbage.elements.indexOf(el)] = null;
			el.htmlElement = el.$tmp = el = null;
		}
		Garbage.elements.remove(null);
	},

	empty: function(){
		Garbage.collect(window);
		Garbage.collect(document);
		Garbage.trash(Garbage.elements);
	}

};

window.addListener('beforeunload', function(){
	window.addListener('unload', Garbage.empty);
	if (window.ie) window.addListener('unload', CollectGarbage);
});

Element.extend({

	scrollTo: function(x, y){
		this.scrollLeft = x;
		this.scrollTop = y;
	},

	getSize: function(){
		return {
			'scroll': {'x': this.scrollLeft, 'y': this.scrollTop},
			'size': {'x': this.offsetWidth, 'y': this.offsetHeight},
			'scrollSize': {'x': this.scrollWidth, 'y': this.scrollHeight}
		};
	},

	getPosition: function(overflown){
		overflown = overflown || [];
		var el = this, left = 0, top = 0;
		do {
			left += el.offsetLeft || 0;
			top += el.offsetTop || 0;
			el = el.offsetParent;
		} while (el);
		overflown.each(function(element){
			left -= element.scrollLeft || 0;
			top -= element.scrollTop || 0;
		});
		return {'x': left, 'y': top};
	},

	getTop: function(overflown){
		return this.getPosition(overflown).y;
	},

	getLeft: function(overflown){
		return this.getPosition(overflown).x;
	},

	getCoordinates: function(overflown){
		var position = this.getPosition(overflown);
		var obj = {
			'width': this.offsetWidth,
			'height': this.offsetHeight,
			'left': position.x,
			'top': position.y
		};
		obj.right = obj.left + obj.width;
		obj.bottom = obj.top + obj.height;
		return obj;
	}

});

window.extend({

	getWidth: function(){
		if (this.webkit419) return this.innerWidth;
		if (this.opera) return document.body.clientWidth;
		return document.documentElement.clientWidth;
	},

	getHeight: function(){
		if (this.webkit419) return this.innerHeight;
		if (this.opera) return document.body.clientHeight;
		return document.documentElement.clientHeight;
	},

	getScrollWidth: function(){
		if (this.ie) return Math.max(document.documentElement.offsetWidth, document.documentElement.scrollWidth);
		if (this.webkit) return document.body.scrollWidth;
		return document.documentElement.scrollWidth;
	},

	getScrollHeight: function(){
		if (this.ie) return Math.max(document.documentElement.offsetHeight, document.documentElement.scrollHeight);
		if (this.webkit) return document.body.scrollHeight;
		return document.documentElement.scrollHeight;
	},

	getScrollLeft: function(){
		return this.pageXOffset || document.documentElement.scrollLeft;
	},

	getScrollTop: function(){
		return this.pageYOffset || document.documentElement.scrollTop;
	},

	getSize: function(){
		return {
			'size': {'x': this.getWidth(), 'y': this.getHeight()},
			'scrollSize': {'x': this.getScrollWidth(), 'y': this.getScrollHeight()},
			'scroll': {'x': this.getScrollLeft(), 'y': this.getScrollTop()}
		};
	},
	getPosition: function(){return {'x': 0, 'y': 0};}

});

var Fx = {};

Fx.Base = new Class({

	options: {
		onStart: Class.empty,
		onComplete: Class.empty,
		onCancel: Class.empty,
		transition: function(p){
			return -(Math.cos(Math.PI * p) - 1) / 2;
		},
		duration: 500,
		unit: 'px',
		wait: true,
		fps: 50
	},

	initialize: function(options){
		this.element = this.element || null;
		this.setOptions(options);
		if (this.options.initialize) this.options.initialize.call(this);
	},

	step: function(){
		var time = $time();
		if (time < this.time + this.options.duration){
			this.delta = this.options.transition((time - this.time) / this.options.duration);
			this.setNow();
			this.increase();
		} else {
			this.stop(true);
			this.set(this.to);
			this.fireEvent('onComplete', this.element, 10);
			this.callChain();
		}
	},

	set: function(to){
		this.now = to;
		this.increase();
		return this;
	},

	setNow: function(){
		this.now = this.compute(this.from, this.to);
	},

	compute: function(from, to){
		return (to - from) * this.delta + from;
	},

	start: function(from, to){
		if (!this.options.wait) this.stop();
		else if (this.timer) return this;
		this.from = from;
		this.to = to;
		this.change = this.to - this.from;
		this.time = $time();
		this.timer = this.step.periodical(Math.round(1000 / this.options.fps), this);
		this.fireEvent('onStart', this.element);
		return this;
	},

	stop: function(end){
		if (!this.timer) return this;
		this.timer = $clear(this.timer);
		if (!end) this.fireEvent('onCancel', this.element);
		return this;
	}/*compatibility*/,

	custom: function(from, to){
		return this.start(from, to);
	},

	clearTimer: function(end){
		return this.stop(end);
	}

});

Fx.Base.implement(new Chain, new Events, new Options);

Fx.CSS = {

	select: function(property, to){
		if (property.test(/color/i)) return this.Color;
		var type = $type(to);
		if ((type == 'array') || (type == 'string' && to.contains(' '))) return this.Multi;
		return this.Single;
	},

	parse: function(el, property, fromTo){
		if (!fromTo.push) fromTo = [fromTo];
		var from = fromTo[0], to = fromTo[1];
		if (!$chk(to)){
			to = from;
			from = el.getStyle(property);
		}
		var css = this.select(property, to);
		return {'from': css.parse(from), 'to': css.parse(to), 'css': css};
	}

};

Fx.CSS.Single = {

	parse: function(value){
		return parseFloat(value);
	},

	getNow: function(from, to, fx){
		return fx.compute(from, to);
	},

	getValue: function(value, unit, property){
		if (unit == 'px' && property != 'opacity') value = Math.round(value);
		return value + unit;
	}

};

Fx.CSS.Multi = {

	parse: function(value){
		return value.push ? value : value.split(' ').map(function(v){
			return parseFloat(v);
		});
	},

	getNow: function(from, to, fx){
		var now = [];
		for (var i = 0; i < from.length; i++) now[i] = fx.compute(from[i], to[i]);
		return now;
	},

	getValue: function(value, unit, property){
		if (unit == 'px' && property != 'opacity') value = value.map(Math.round);
		return value.join(unit + ' ') + unit;
	}

};

Fx.CSS.Color = {

	parse: function(value){
		return value.push ? value : value.hexToRgb(true);
	},

	getNow: function(from, to, fx){
		var now = [];
		for (var i = 0; i < from.length; i++) now[i] = Math.round(fx.compute(from[i], to[i]));
		return now;
	},

	getValue: function(value){
		return 'rgb(' + value.join(',') + ')';
	}

};

Fx.Style = Fx.Base.extend({

	initialize: function(el, property, options){
		this.element = $(el);
		this.property = property;
		this.parent(options);
	},

	hide: function(){
		return this.set(0);
	},

	setNow: function(){
		this.now = this.css.getNow(this.from, this.to, this);
	},

	set: function(to){
		this.css = Fx.CSS.select(this.property, to);
		return this.parent(this.css.parse(to));
	},

	start: function(from, to){
		if (this.timer && this.options.wait) return this;
		var parsed = Fx.CSS.parse(this.element, this.property, [from, to]);
		this.css = parsed.css;
		return this.parent(parsed.from, parsed.to);
	},

	increase: function(){
		this.element.setStyle(this.property, this.css.getValue(this.now, this.options.unit, this.property));
	}

});

Element.extend({

	effect: function(property, options){
		return new Fx.Style(this, property, options);
	}

});

Fx.Styles = Fx.Base.extend({

	initialize: function(el, options){
		this.element = $(el);
		this.parent(options);
	},

	setNow: function(){
		for (var p in this.from) this.now[p] = this.css[p].getNow(this.from[p], this.to[p], this);
	},

	set: function(to){
		var parsed = {};
		this.css = {};
		for (var p in to){
			this.css[p] = Fx.CSS.select(p, to[p]);
			parsed[p] = this.css[p].parse(to[p]);
		}
		return this.parent(parsed);
	},

	start: function(obj){
		if (this.timer && this.options.wait) return this;
		this.now = {};
		this.css = {};
		var from = {}, to = {};
		for (var p in obj){
			var parsed = Fx.CSS.parse(this.element, p, obj[p]);
			from[p] = parsed.from;
			to[p] = parsed.to;
			this.css[p] = parsed.css;
		}
		return this.parent(from, to);
	},

	increase: function(){
		for (var p in this.now) this.element.setStyle(p, this.css[p].getValue(this.now[p], this.options.unit, p));
	}

});

Element.extend({

	effects: function(options){
		return new Fx.Styles(this, options);
	}

});

Fx.Elements = Fx.Base.extend({

	initialize: function(elements, options){
		this.elements = $$(elements);
		this.parent(options);
	},

	setNow: function(){
		for (var i in this.from){
			var iFrom = this.from[i], iTo = this.to[i], iCss = this.css[i], iNow = this.now[i] = {};
			for (var p in iFrom) iNow[p] = iCss[p].getNow(iFrom[p], iTo[p], this);
		}
	},

	set: function(to){
		var parsed = {};
		this.css = {};
		for (var i in to){
			var iTo = to[i], iCss = this.css[i] = {}, iParsed = parsed[i] = {};
			for (var p in iTo){
				iCss[p] = Fx.CSS.select(p, iTo[p]);
				iParsed[p] = iCss[p].parse(iTo[p]);
			}
		}
		return this.parent(parsed);
	},

	start: function(obj){
		if (this.timer && this.options.wait) return this;
		this.now = {};
		this.css = {};
		var from = {}, to = {};
		for (var i in obj){
			var iProps = obj[i], iFrom = from[i] = {}, iTo = to[i] = {}, iCss = this.css[i] = {};
			for (var p in iProps){
				var parsed = Fx.CSS.parse(this.elements[i], p, iProps[p]);
				iFrom[p] = parsed.from;
				iTo[p] = parsed.to;
				iCss[p] = parsed.css;
			}
		}
		return this.parent(from, to);
	},

	increase: function(){
		for (var i in this.now){
			var iNow = this.now[i], iCss = this.css[i];
			for (var p in iNow) this.elements[i].setStyle(p, iCss[p].getValue(iNow[p], this.options.unit, p));
		}
	}

});

Fx.Transition = function(transition, params){
	params = params || [];
	if ($type(params) != 'array') params = [params];
	return $extend(transition, {
		easeIn: function(pos){
			return transition(pos, params);
		},
		easeOut: function(pos){
			return 1 - transition(1 - pos, params);
		},
		easeInOut: function(pos){
			return (pos <= 0.5) ? transition(2 * pos, params) / 2 : (2 - transition(2 * (1 - pos), params)) / 2;
		}
	});
};

Fx.Transitions = new Abstract({

	linear: function(p){
		return p;
	}

});

Fx.Transitions.extend = function(transitions){
	for (var transition in transitions){
		Fx.Transitions[transition] = new Fx.Transition(transitions[transition]);
		Fx.Transitions.compat(transition);
	}
};

Fx.Transitions.compat = function(transition){
	['In', 'Out', 'InOut'].each(function(easeType){
		Fx.Transitions[transition.toLowerCase() + easeType] = Fx.Transitions[transition]['ease' + easeType];
	});
};

Fx.Transitions.extend({

	Pow: function(p, x){
		return Math.pow(p, x[0] || 6);
	},

	Expo: function(p){
		return Math.pow(2, 8 * (p - 1));
	},

	Circ: function(p){
		return 1 - Math.sin(Math.acos(p));
	},

	Sine: function(p){
		return 1 - Math.sin((1 - p) * Math.PI / 2);
	},

	Back: function(p, x){
		x = x[0] || 1.618;
		return Math.pow(p, 2) * ((x + 1) * p - x);
	},

	Bounce: function(p){
		var value;
		for (var a = 0, b = 1; 1; a += b, b /= 2){
			if (p >= (7 - 4 * a) / 11){
				value = - Math.pow((11 - 6 * a - 11 * p) / 4, 2) + b * b;
				break;
			}
		}
		return value;
	},

	Elastic: function(p, x){
		return Math.pow(2, 10 * --p) * Math.cos(20 * p * Math.PI * (x[0] || 1) / 3);
	}

});

['Quad', 'Cubic', 'Quart', 'Quint'].each(function(transition, i){
	Fx.Transitions[transition] = new Fx.Transition(function(p){
		return Math.pow(p, [i + 2]);
	});
	Fx.Transitions.compat(transition);
});

/**
 * @todo 
 * dodac info o autorze i prawach autorskich
 * dodac opcję pre-ladowania wszystkich zdjec po zaladowaniu strony
 * po co slidheshow gdy jedno zdjecia
 * dodac grupowanie obrazkow w rel: jskelly[gr1], jskelly[gr2]
 * opcja bSlideShowLoop = true
 * dodac mozliwosc dodawania pluginow np. efektow do zdjec
 */

var imgs = Array ();
var imgall = Array ();
var imgsmall = Array ();
var bigImage = new Image ();
var loaderImage = new Image ();
var slideshowImage = new Image ();
var nInterval = 0;
var nIntervalInd = 0;
var bSlideShow = false;
var sDesc;
var bWindowLoaded = false;
var bHideAll = false;
var bHideLeftMenu = false;
var bShowSwitchThumbs = true;
/* user defined vars */
if (!nIntervalTime) var nIntervalTime = 3000; /*miliseconds*/
if (!sLeftMenuImg) var sLeftMenuImg = 'http://www.plazowka.net/gfx/img_left.gif';
if (!sLeftMenuImgInd) var sLeftMenuImgInd = 'http://www.plazowka.net/gfx/img_left2.gif';
if (!sCloseImg) var sCloseImg = 'http://www.plazowka.net/gfx/img_right.gif'
if (!sAjaxLoader) var sAjaxLoader = 'http://www.kello.pl/_img/hotlink/ajax-loader.gif';
if (!bShowDescription) var bShowDescription = true;

function jskelly_open (url,text) {
	bHideLeftMenu = true;
	bShowSwitchThumbs = false;
 	showBigImage(url,text,true);
}

function changePic (type) {
	if (type == null) {
		type = 'next';
		/* if slideshow is running stop it until image is loaded */
		if (bSlideShow || nInterval>0) {
			clearInterval (nInterval);
			nInterval = 0;
		}
	} else if (bSlideShow) return 0;
	$('loader_div').style.display = 'block';
	//$('image_div').style.backgroundImage = ''; commented with version 097
	$('close_div').style.display = 'none';
	$('lmenu_div').style.display = 'none';
	$('desc_div').style.display = 'none';
	$('desc_div').innerHTML = '';
	nIndex = imgall.indexOf(bigImage.src); // index of the current image -> switch to the next index
	if (type == 'next')
		nNextIndex = nIndex + 1;
	else
		nNextIndex = nIndex - 1;
	if (nNextIndex >= imgall.length) nNextIndex = 0;
		else if (nNextIndex < 0) nNextIndex = imgall.length - 1;
	bigImage = new Image ();
	sDesc = imgs[nNextIndex].childNodes[0].alt;
	bigImage.src = imgall[nNextIndex];
	if (bigImage.complete) imageLoaded ();
		else bigImage.onload = imageLoaded;	
}

function runSlideShow () {
	if (bSlideShow) {
		bSlideShow = false;
		clearInterval (nInterval);
		nInterval = 0;
		clearInterval (nIntervalInd);
		nIntervalInd = 0;
		$('lmenu_div').style.backgroundImage = 'url('+sLeftMenuImg+')';
	} else {
		bSlideShow = true;
		nInterval = setInterval ("changePic()", nIntervalTime);
		$('lmenu_div').style.backgroundImage = 'url('+slideshowImage.src+')';
/*		nIntervalInd = setInterval ("slideShowIndicator()", 300); */
	}
}

/* changing images instead of animated gif */
function slideShowIndicator () {
	if ($('lmenu_div').style.backgroundImage.indexOf(''+sLeftMenuImg+'') > 0)
		$('lmenu_div').style.backgroundImage = 'url('+slideshowImage.src+')';
	else
		$('lmenu_div').style.backgroundImage = 'url('+sLeftMenuImg+')';
}

function showBigImage (rel, text, bSingleOpen) {
	bHideAll = false;	
	if (!bSingleOpen) sDesc = text.childNodes[0].alt;
		else sDesc = text;
	$('curtain_div').style.display = 'block';
	$('loader_div').style.display = 'block';
	var myFx = new Fx.Style ('curtain_div', 'opacity', {
		duration: 1000,
		onComplete: function () {
			$('image_div').style.display = 'block';
			bigImage.src = rel;
			if (bigImage.complete) imageLoaded ();
				else bigImage.onload = imageLoaded;
		}
	});
	myFx.start(0,0.6);
}

function hideAll () {
	$('image_div').style.display = 'none';
	$('lmenu_div').style.display = 'none';
	$('close_div').style.display = 'none';	
	$('desc_div').style.display = 'none';
	$('loader_div').style.display = 'none';
	$('info_div').style.display = 'none';	
	$('image_div').style.backgroundImage = '';
	$('next_img').style.display = 'none';
	$('next_div').style.display = 'none';
	$('prev_img').style.display = 'none';
	$('prev_div').style.display = 'none';
	bShowSwitchThumbs = true;
	if (bSlideShow || nInterval>0) {
		runSlideShow ();
	}
	bHideAll = true;
	bigImage.src = '';
	var myFx = new Fx.Style ('curtain_div', 'opacity', {
		duration: 500,
		onComplete: function () {
		}
	});
	myFx.start(0.6,0);	
}

function imageLoaded () {
	if (bHideAll) {
		hideAll();
		return;
	}
	$('image_div').style.backgroundImage = ''; //added with version 097
	$('close_div').style.display = 'none';
	$('lmenu_div').style.display = 'none';
	isize = $('image_div').getSize();
	ipos = $('image_div').getPosition();
	wwidth = window.getWidth() || document.body.clientWidth;
	wheight = window.getHeight() || document.body.clientHeight;
	if (bigImage.width > wwidth) {
		newposx = 50;
	} else {
		newposx = ipos.x - Math.round((bigImage.width+10-isize['size'].x) / 2);
	}
	newposy = ycenter() - (wheight/200-1)*100;
	/*$('loader_div').style.top = ycenter()-loaderImage.height/2 +'px';*/
	$('loader_div').style.top = newposy+20-loaderImage.height/2 +'px';
	myFx = new Fx.Styles ('image_div', {
		duration: 500,
		onComplete: function () {
			if (bHideAll) return;
			$('image_div').style.backgroundImage = 'url('+bigImage.src+')';
			$('loader_div').style.display = 'none';
			/* close button position */
			with ($('close_div').style) {
				top = newposy+3 + 'px';
				left = (newposx+bigImage.width-90) + 'px';
				display = 'block';
				zIndex = '920';
			}
			with ($('lmenu_div').style) {
				top = newposy+3 + 'px';
				left = newposx+5 + 'px';
				if (bHideLeftMenu) bHideLeftMenu = false;
					else display = 'block';
				zIndex = '920';
			}
/* dodane098 */
			if (bShowSwitchThumbs) {
				with ($('next_div').style) {
					display = 'block';
					top = newposy+23 + 'px';
					left = (newposx+bigImage.width-140) + 'px';
					height = bigImage.height-20 + 'px';
				}
				with ($('next_img')) {
					nIndex = imgall.indexOf(bigImage.src); /* index of the current image -> switch to the next index */
					nNextIndex = nIndex + 1;
					if (nNextIndex >= imgall.length) nNextIndex = 0;
					//src = imgsmall[nNextIndex];
					style.background = 'url('+imgsmall[nNextIndex]+') no-repeat center center';
					style.left = (newposx+bigImage.width-130) + 'px';
					style.top = newposy+53 + 'px';
					display = 'none';
					opacity = '0.7';
				}
				with ($('prev_div').style) {
					display = 'block';
					top = newposy+23 + 'px';
					left = (newposx+10) + 'px';
					height = bigImage.height-20 + 'px';
				}
				with ($('prev_img')) {
					nIndex = imgall.indexOf(bigImage.src); /* index of the current image -> switch to the prev index */
					nPrevIndex = nIndex - 1;
					if (nPrevIndex <= 0) nPrevIndex = imgall.length-1;
					//src = imgsmall[nPrevIndex];
					style.background = 'url('+imgsmall[nPrevIndex]+') no-repeat center center';
					style.left = (newposx+20) + 'px';
					style.top = newposy+53 + 'px';
					display = 'none';
					opacity = '0.7';
				}
			}
/* dodane098 */
			if (bShowDescription && sDesc!='') {
				$('desc_div').innerHTML = sDesc;
				with ($('desc_div').style) {
					width = bigImage.width-10 + 'px';
					if (navigator.appName.indexOf('Explorer') > 0) width = bigImage.width+10 + 'px';
					top = newposy+6+bigImage.height + 'px';
					left = newposx + 'px';
					opacity = '0';
					filter = 'alpha(opacity=0)';
					display = 'block';
					zIndex = '930';
					textAlign = 'left';
				}
				var myFx = new Fx.Style ('desc_div', 'opacity', {
					duration: 500
				});
				if (!bHideAll) myFx.start(0,1);
			}
			/* if slideshow is running play it again because it was stopped because image was not loaded */
			if (bSlideShow || nInterval>0) nInterval = setInterval ("changePic()", nIntervalTime);
		}
	});
	myFx.start({
		'width': [isize['size'].x,bigImage.width+10],
		'left': [ipos.x,newposx],
		'height': [isize['size'].y,bigImage.height+10],
		'top': [ipos.y,newposy]
	});
}

function curtainOnChange () {
	if ($('curtain_div').style.display == 'none') return 0;
	wwidth = window.getWidth() || document.body.clientWidth;
	wheight = window.getHeight() || document.body.clientHeight;
	pagesize = getPageSizeWithScroll();
	xheight = pagesize[1];
	xwidth = document.body.clientWidth;
	with ($('curtain_div').style) {
		width = wwidth+'px';
		height = xheight+'px';
	}
	$('info_div').style.top = Math.round(ycenter()-wheight/2) + 'px';
}

window.onresize = function () {
	if (bWindowLoaded) curtainOnChange();
}
window.onscroll = function () {
	if (bWindowLoaded) curtainOnChange();
}

/* pobierac po zaladowaniu czy po kliku? */
window.onload = function () {
	loaderImage.src = sAjaxLoader;
	slideshowImage.src = sLeftMenuImgInd;
	imgs = getTagsByRef ('a', 'jskelly');
 	for (i=0; i<imgs.length; i++) {
		imgall.push (imgs[i].href);
		imgsmall.push(imgs[i].childNodes[0].src);
		imgs[i].rel = imgs[i].href;
		/*imgs[i].href = document.location.href.replace('#','')+'#'; */
		imgs[i].onclick = function () {
			showBigImage (this.rel, this); /*instead of event -> stupid ie*/
			return false;
		}
	}
	/* stworzenie diva-zaslony */
	rBody = window.document.body;
	rCurtainDiv = document.createElement ('div');
	wwidth = window.getWidth() || document.body.clientWidth;
	wheight = window.getHeight() || document.body.clientHeight;
	pagesize = getPageSizeWithScroll();
	xheight = pagesize[1];
	xwidth = document.body.clientWidth;
	with (rCurtainDiv.style) {
		display = 'none';
		position = 'absolute';
		top = '0px';
		left = '0px';
		width = wwidth+'px';
		height = xheight+'px';
		backgroundColor = 'black';
		opacity = '0';
		filter = 'alpha(opacity=0)';
		zIndex = '900';
	}
	rCurtainDiv.setAttribute ('id','curtain_div');
	rCurtainDiv.onclick = function () {
		hideAll ();
	}
	rBody.appendChild (rCurtainDiv);
	rClose = document.createElement ('div');
	/* setAttribute for style doesn't work in ie */
	with (rClose.style) {
		position = 'absolute';
		width = '100px';
		height = '20px';
		backgroundImage = 'url('+sCloseImg+')';
		display = 'none';
		zIndex = '930';
		cursor = 'pointer'
	}
	rClose.setAttribute ('id', 'close_div');
	rBody.appendChild (rClose);
	rClose.onclick = hideAll;
	rMenu = document.createElement ('div');
	with (rMenu.style) {
		position = 'absolute';
		width = '200px';
		height = '20px';
		backgroundImage = 'url('+sLeftMenuImg+')';
		display = 'none';
		zIndex = '930';
		cursor = 'pointer'		
	}
	rMenu.setAttribute ('id', 'lmenu_div');
	rBody.appendChild (rMenu);
	rMenuPrev = document.createElement ('div');
	/* setAttribute for style doesn't work in ie */
	with (rMenuPrev.style) {
		width = '40px';
		height = '20px';
		cssFloat = 'left';
		styleFloat = 'left';
	}
	rMenu.appendChild (rMenuPrev);
	rMenuPrev.onclick = function () {
		changePic ('prev');
	}
	rMenuNext = document.createElement ('div');
	with (rMenuNext.style) {
		width = '40px';
		height = '20px';
		cssFloat = 'left';
		styleFloat = 'left';
	}
	rMenu.appendChild (rMenuNext);
	rMenuNext.onclick = function () {
		changePic ('next');
	}
	if (imgs.length > 1) { /* slideshow is not neccessary when only one picture */
		rMenuSlide = document.createElement ('div');
		with (rMenuSlide.style) {
			width = '120px';
			height = '20px';
			cssFloat = 'left';
			styleFloat = 'left';
		}
		rMenuSlide.setAttribute ('title', 'start/stop slideshow');
		rMenu.appendChild (rMenuSlide);
		rMenuSlide.onclick = function () {
			runSlideShow ();
		}
	}
	rInfo = document.createElement ('div');
	with (rInfo.style) {
		width = '50px';
		height = '20px';
		position = 'absolute';
		cssFloat = 'right';
		styleFloat = 'right';
		textAlign = 'center';
	}
	rInfo.setAttribute ('id', 'info_div');
	rInfo.innerHTML = '<a href="http://www.kello.pl/soft/jskelly" target="_blank" style="color: #999999; text-decoration: none; font-family: verdana, arial; font-size: 9px">jskelly </a>';
	rCurtainDiv.appendChild (rInfo);
	rLoaderDiv = document.createElement ('div');
	with (rLoaderDiv.style) {
		display = 'none';
		position = 'absolute';
		top = Math.round(wheight/2) - '10' + 'px';
		left = Math.round(wwidth/2) - '20' + 'px';
		width = '56px';
		height = '21px';
		background = 'transparent url('+loaderImage.src+') no-repeat center center';
		zIndex = '920';
	}
	rLoaderDiv.setAttribute ('id', 'loader_div');
	rBody.appendChild (rLoaderDiv);
	rImageDiv = document.createElement ('div');
	with (rImageDiv.style) {
		display = 'none';
		position = 'absolute';
		width = '200px';
		height = '300px';
		//top = Math.round(wheight/2) - '150' + 'px';
		newposy = ycenter() - (wheight/200-1)*100;
		top = $('loader_div').style.top = newposy+20-loaderImage.height/2 +'px';
		left = Math.round(wwidth/2) - '100' + 'px';
		border = '0px solid white';
		backgroundColor = 'white';
		background = 'white no-repeat center center';
		zIndex = '910';
	}
	rImageDiv.setAttribute ('id', 'image_div');
	rBody.appendChild (rImageDiv);
	rDesc = document.createElement ('div');
	rDesc.setAttribute ('id', 'desc_div');
	with (rDesc.style) {
		display = 'none';
		position = 'absolute';
		height = '23px';
		if (navigator.appName.indexOf('Explorer') > 0) height = '50px';
		backgroundColor = 'white';
		/*opacity = 0.5; */
		fontSize  = '12px';
		fontFamily = 'Arial';
		color = 'black';
		padding = '10px';
		overflow = 'hidden';
		borderBottom = '8px solid white';
	}
	rBody.appendChild (rDesc);
/* dodane098 */
	if (bShowSwitchThumbs) {
		rNext = document.createElement ('div');
		rNext.setAttribute ('id', 'next_div');
		with (rNext.style) {
			dispaly = 'none';
			position = 'absolute';
			width = '150px';
			backgroundColor = 'transparent';
			zIndex = 930;
		}
		rBody.appendChild (rNext);
		rNextPic = document.createElement ('div');
		rNextPic.setAttribute ('id', 'next_img');
		with (rNextPic.style) {
			display = 'none';
			position = 'absolute';
			width = '120px';
			height = '90px';
			border = '1px solid white';
			backgroundPosition = 'center center';
			opacity = '0.7';
			zIndex = 940;
			cursor = 'pointer';
		}
		rBody.appendChild (rNextPic);
		rNext.onmouseover = function () {
			if (bSlideShow) return;
			$('next_img').style.display = 'block';
			$('next_img').onmouseover = function () {
				this.style.display = 'block';
				this.style.opacity = '1';
			}
		}
		rNext.onmouseout = function() {
			$('next_img').style.display = 'none';
		}
		rNextPic.onmouseout = function() {
			this.style.display = 'none';
			this.style.opacity = '0.7';
		}
		rNextPic.onclick = function () {
			changePic('next');
			this.style.display = 'none';
			$('next_div').style.display = 'none';
		}
		rPrev = document.createElement ('div');
		rPrev.setAttribute ('id', 'prev_div');
		with (rPrev.style) {
			dispaly = 'none';
			position = 'absolute';
			width = '150px';
			backgroundColor = 'transparent';
			zIndex = 930;
		}
		rBody.appendChild (rPrev);
		rPrevPic = document.createElement ('div');
		rPrevPic.setAttribute ('id', 'prev_img');
		with (rPrevPic.style) {
			display = 'none';
			position = 'absolute';
			width = '120px';
			height = '90px';
			border = '1px solid white';
			backgroundPosition = 'center center';
			opacity = '0.7';
			zIndex = 940;
			cursor = 'pointer';
		}
		rBody.appendChild (rPrevPic);
		rPrev.onmouseover = function () {
			if (bSlideShow) return;
			$('prev_img').style.display = 'block';
			$('prev_img').onmouseover = function () {
				this.style.display = 'block';
				this.style.opacity = '1';
			}
		}
		rPrev.onmouseout = function() {
			$('prev_img').style.display = 'none';
		}
		rPrevPic.onmouseout = function() {
			this.style.display = 'none';
			this.style.opacity = '0.7';
		}
		rPrevPic.onclick = function () {
			this.style.display = 'none';
			$('prev_div').style.display = 'none';
			changePic('prev');
		}
		rMenuPrev.onmouseover = rPrev.onmouseover;
		rMenuPrev.onmouseout = rPrev.onmouseout;
		rMenuNext.onmouseover = rNext.onmouseover;
		rMenuNext.onmouseout = rNext.onmouseout;
	} // showSwitchThumbs
/* .dodane098 */ 
	bWindowLoaded = true;
}

/* from kelite.js */
function getTagsByRef (TAG, REL) {
	var elementy = Array ();
	var j = 0;
	for (i=0; (ab=document.getElementsByTagName(TAG)[i]); i++) {
		if (rel=ab.getAttribute('rel')) {
			if (rel.indexOf(REL) != -1) elementy[j++] = ab;
		}
	}
	return elementy;
}

function getPageSizeWithScroll () {
	if (window.innerHeight && window.scrollMaxY) {// Firefox
		yWithScroll = window.innerHeight + window.scrollMaxY;
		xWithScroll = window.innerWidth + window.scrollMaxX;
	} else if (document.body.scrollHeight > document.body.offsetHeight){ // all but Explorer Mac
		yWithScroll = document.body.scrollHeight;
		xWithScroll = document.body.scrollWidth;
	} else { // works in Explorer 6 Strict, Mozilla (not FF) and Safari
		yWithScroll = document.body.offsetHeight;
		xWithScroll = document.body.offsetWidth;
  	}
	arrayPageSizeWithScroll = new Array (xWithScroll,yWithScroll);
	/*alert( 'The height is ' + yWithScroll + ' and the width is ' + xWithScroll ); */
	return arrayPageSizeWithScroll;
}

function ycenter () {
		var przesuniecie = document.documentElement.scrollTop || document.body.scrollTop;
		if (document.all) bwys = document.body.clientHeight;
		else bwys = document.documentElement.clientHeight;
		wspY = Math.round(bwys/2);
		return wspY + przesuniecie;
}