/*  Object bsc
 *  Store functions
/*--------------------------------------------------------------------------*/
var bsc = {
	cacheData: new Array(),
	
	isIe: navigator.userAgent.indexOf("MSIE") != -1,
	
	show: function (element) {
		return Element.setStyle(element, {visibility:"visible"});
	},
	
	hide: function (element) {
		return Element.setStyle(element, {visibility:"hidden"});
	},
	
	execute: function (callback, time) {
		return new PeriodicalExecuter (callback, time);
	},
	
	timer: function (callback, time) {
		this.execute(callback, time);
	},
	
	attr: function (element, attribute, value) {
		if (value) {element.setAttribute(attribute, value); return value;}
		return element.readAttribute(attribute);		
	},
	
	hasAttributeValue: function (element, attribute, value) {
		return element.readAttribute(attribute) == value;	
	},
	
	div: function (container) {
		container = $(container);
		var div = document.createElement('div');
		if (container) container.appendChild(div);				
		div.innerHTML = "";
		return $(div);
	},
	
	a: function (container) {
		var a = document.createElement('a');
		if (container) container.appendChild(a);				
		a.innerHTML = "";
		return $(a);
	},
	
	setBackground: function (element, url) {
		Element.setStyle(
			element, {			
			filter: "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+ url +"', sizingMethod='scale')",
			background: !this.isIe ? "url("+ url +")" : "none"
		});
	},
	
	setOpacity: function (element, value) {
		element.setStyle({opacity:value});
		element.setStyle({filter:"progid:DXImageTransform.Microsoft.Alpha(opacity=" + value*100 + ")"});		
	},
	
	parsePercent: function (numder, percent) {
		if (typeof percent == 'string' && /^\d+%$/.test(percent)) {
			return (parseInt(percent) * numder) / 100;
		}
		return percent;
	},
	
	fixPng: function (element) {
		try {fixPNG(element);} catch(e) { };
	},
	
	createPreloader: function (element, content, isShow) {
		var width  = this.width  || element.getWidth();
		var height = this.height || element.getHeight();
		if (/\.(gif|jpg)$/.test(content)) {
			return (new ExImage(element, {
				isPreloader: false,
				src: 		 content,
				isShowImage: false,
				onComplete: function (element) {				
					element.setCenter(width,height);	
					this.show(element);
				}.bind(this)
			})).image;
		}else {
			var object = this.div(element);	
			object.update(content);
			object.setCenter(width,height);			
			object = $(object);
			this[isShow ? "show" : "hide"](object);
			return object;
		}
	},
	
	removePreloader: function () {		
		Element.remove(this.preloader);		
	},
	
	cache: function (string) {
		if (this.cacheData[string])
			return true;
		this.cacheData[string] = true;
		return false;		
	},	
	
	getPageSize: function () {		
		var xScroll, yScroll;
		
		if (window.innerHeight && window.scrollMaxY) {	
			xScroll = window.innerWidth + window.scrollMaxX;
			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) {
			if(document.documentElement.clientWidth){
				windowWidth = document.documentElement.clientWidth; 
			} else {
				windowWidth = self.innerWidth;
			}
			windowHeight = self.innerHeight;
		} else if (document.documentElement && document.documentElement.clientHeight) {
			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 = xScroll;		
		} else {
			pageWidth = windowWidth;
		}
		
		return [pageWidth, pageHeight, windowWidth, windowHeight];
	},
	
	getPageScroll: function () {
		var xScroll, yScroll;	
		
		if (self.pageYOffset) {
			yScroll = self.pageYOffset;
			xScroll = self.pageXOffset;
		} else if (document.documentElement && document.documentElement.scrollTop) {
			yScroll = document.documentElement.scrollTop;
			xScroll = document.documentElement.scrollLeft;
		} else if (document.body) {
			yScroll = document.body.scrollTop;
			xScroll = document.body.scrollLeft;	
		}
		
		return [xScroll, yScroll];
	},
	
	showSelectBoxes: function () {
		var selects = document.getElementsByTagName("select");
		for (i = 0; i != selects.length; i++) {
			selects[i].style.visibility = "visible";
		}
	},
		
	hideSelectBoxes: function () {
		var selects = document.getElementsByTagName("select");
		for (i = 0; i != selects.length; i++) {
			selects[i].style.visibility = "hidden";
		}
	},
	
	showFlash: function () {
		var flashObjects = document.getElementsByTagName("object");
		for (i = 0; i < flashObjects.length; i++) {
			flashObjects[i].style.visibility = "visible";
		}	
		var flashEmbeds = document.getElementsByTagName("embed");
		for (i = 0; i < flashEmbeds.length; i++) {
			flashEmbeds[i].style.visibility = "visible";
		}
	},
	
	hideFlash: function () {
		var flashObjects = document.getElementsByTagName("object");
		for (i = 0; i < flashObjects.length; i++) {
			flashObjects[i].style.visibility = "hidden";
		}	
		var flashEmbeds = document.getElementsByTagName("embed");
		for (i = 0; i < flashEmbeds.length; i++) {
			flashEmbeds[i].style.visibility = "hidden";
		}	
	}
}
/*  Class ExImage
/*--------------------------------------------------------------------------*/
var ExImage = Class.create();

Object.extend(Object.extend(ExImage.prototype, bsc), {
	initialize: function(container) {
		this.success   = 0;
		this.image 	   = null;		
		this.preloader = null;		
		container = $(container);

		var options = Object.extend({
			container:		  container,
			isShowImage: 	  true,
			isShowPreloader:  true,
			isPreloader:  	  false,
			preloaderContent: 'XPreloader',
			src: 			  '',
			width: 			  null,
			height: 		  null,
			onComplete:		  Prototype.emptyFunction
		}, arguments[1] || {});
		
		this.width   = options.width;
		this.height  = options.height;		
		this.options = options;
		
		this.eventComplete = this.onComplete.bindAsEventListener(this);
		
		this.setup(options);
	},
	
	setup: function (options) {		
		this.image = $(new Image());
		this.hide(this.image);
		if (options.container) {
			options.container.cleanWhitespace();
			options.container.appendChild(this.image);
		}
		this.success = 1;		
		this.setOnLoadEvent(this.image);
		if (options.isPreloader) {
			this.preloader = this.createPreloader(			
				options.container,
				options.preloaderContent,
				options.isShowPreloader
			);
		}
		this.image.setSrc(options.src);
	},
	
	onComplete: function (event) {		
		this.options.onComplete(this.image);
		if (this.options.isPreloader) {			
			this.removePreloader();
		}
		if (this.options.isShowImage) {			
			this.show(this.image);
		}		
		this.success = 2;
		this.stopEvent(this.image);
		if (event) Event.stop(event);		
	},
	
	setOnLoadEvent: function (element) {		
		Element.observe(element, 'load', this.eventComplete);		
	},
	
	stopEvent: function (element) {
		Element.stopObserving(element, 'load', this.eventComplete);	
	}
});
/*  Class HightLight 
/*--------------------------------------------------------------------------*/
var HightLight = Class.create();

Object.extend(Object.extend(HightLight.prototype, bsc), {
	initialize: function () {
		var options = Object.extend({			
			container: 	   document.body,				
			isShowEffect:  true,
			isCloseEffect: true,			
			duration: 	   0.3,
			onClose: 	   Prototype.emptyFunction,
			onResize: 	   Prototype.emptyFunction
		}, arguments[0] || {});
		
		this.options = options;
		
		Element.observe(
			window, 'resize', 
			this.update.bindAsEventListener(this)
		);		
	},
	
	show: function () {
		var options  = this.options;		
		var element  = this.div(options.container);
		this.element = element;
		element.setId('HightLightContainer');
		element.hide();
		
		this.hideSelectBoxes();
		this.hideFlash();
		
		if (options.isShowEffect) {
			var to = element.getOpacity();
			Effect.MyFade(element, {
				from: 	  0.0,
				to:   	  to,
				duration: options.duration,
				beforeSetup: function (effect) {
					this.setOpacity(effect.element, 0);
					effect.element.show();
				}.bind(this),
				afterFinishInternal: function (effect) {
					this.setClick(effect.element);
				}.bind(this)
			});
		}else {			
			element.show();
			this.setClick(element);
		}		
	},
	
	close: function (event) {
		var options = this.options;
		var element = this.element;		
		options.onClose();
		
		this.showSelectBoxes();
		this.showFlash();
		
		if (options.isCloseEffect) {
			var from = element.getOpacity();
			Effect.MyFade(element, {
				from: 	  from,
				to:   	  0.0,
				duration: options.duration,
				beforeSetup: function (effect) {
					this.stopClick(effect.element);
				}.bind(this),
				afterFinishInternal: function (effect) {
					effect.element.remove();
				}.bind(this)
			});
		}else {			
			element.remove();
		}
		if (event) Event.stop(event);		
	},
	
	update: function (event) {
		/*
		var pageSize = this.getPageSize();
		this.element.setWidth(pageSize[0]);
		this.element.setHeight(pageSize[1]);
		*/
		this.options.onResize();
		if (event) Event.stop(event);
	},
	
	setClick: function (element) {
		this.options.close = this.close.bindAsEventListener(this);
		Element.observe(element, 'click', this.options.close);
	},
	
	stopClick: function (element) {		
		Element.stopObserving(element, 'click', this.options.close);
	}
});
/*  Class Gallery
/*--------------------------------------------------------------------------*/ 
var Gallery = Class.create();

Object.extend(Object.extend(Gallery.prototype, bsc), {
	initialize: function () {		
		this.element 	  		= null;		
		this.images 	  		= [];
		this.group		  		= 0;		
		this.offset  	  		= 0;		
		this.navigation   		= null;		
		this.hightlight			= null;
		this.frame				= null;
		this.buttonClose		= null;
		this.lastWidth     		= null;
		this.lastHeight    		= null;
		this.options			= null;		
		this.images[this.group]	= [];
		
		var options = Object.extend({
			find:	   '',			
			tag:	   'A',
			rel:	   'Gallery',
			observe:    true,
			preloader: 'loading.gif'
		}, arguments[0] || {});
		
		options.navigation = {
			onPrev: function (event) {
				this.prev();
				if (event) Event.stop(event);
			}.bind(this),
			onNext: function (event) {
				this.next();
				if (event) Event.stop(event);
			}.bind(this)
		};
		
		options.hightlight = {
			isShowEffect: false,
			onClose: function () {
				this.close();
				this.frame.remove();
				this.buttonClose.remove();
			}.bind(this),
			onResize: function () {				
				var pos = this.setCenter(this.element);
				this.frame.setXY(pos[0], pos[1]);
				this.frame.update();
				this.buttonClose.setXY(pos[0], pos[1]);
				this.buttonClose.update();
			}.bind(this)
		};
		
		options.buttonClose = {			
			onClose: function () {
				this.hightlight.close();
			}.bind(this)
		};
		
		options.effect = {
			x: {
				start: function (effect) {					
					this.navigation.hidePrevLink();
					this.navigation.hideNextLink();
					this.buttonClose.hide();
				}.bind(this),
				update: function (effect) {
					this.frame.update();
				}.bind(this)
			},
			y: {				
				start: function (effect) {
					var element = effect.effects[2].element;
					this.setOpacity(element, 0);
					this.show(element);
					Effect.MyFade(element);				
				}.bind(this),
				update: function (effect) {
					this.frame.update();
				}.bind(this),
				end: function (effect) {
					var element = effect.effects[2].element;
					if (this.isNextLink()) {
						this.navigation.showNextLink();
					}					
					if (this.isPrevLink()) {
						this.navigation.showPrevLink();
					}
					this.hightlight.update();
					this.buttonClose.show();
				}.bind(this)
			}
		};
		
		options.fade = {
			beforeSetup: function (effect) {				
				this.navigation.hidePrevLink();
				this.navigation.hideNextLink();
				var element = effect.element;
				this.setOpacity(element, 0);
				this.show(element);
			}.bind(this),
			afterFinishInternal: function (effect) {
				var element = effect.element;
				if (this.isNextLink()) {
					this.navigation.showNextLink();
				}					
				if (this.isPrevLink()) {
					this.navigation.showPrevLink();
				}
			}.bind(this)
		};
		
		this.options = options;
		
		this.add(options);
	},
	
	next: function () {
		if (this.isNextLink()) {			
			this.offset++;
			this.go();
		}
	},
	
	prev: function () {
		if (this.isPrevLink()) {
			this.offset--;
			this.go();
		}
	},
	
	go: function () {
		var element    = this.element;		
		var options    = this.options;		
		var lastWidth  = 0;
		var lastHeight = 0;
		
		if (this.last) {
			lastWidth  = this.last.width;
			lastHeight = this.last.height;
			this.last.remove();
		}
		
		this.navigation.hidePrevLink();
		this.navigation.hideNextLink();
		
		element.setPreloader(options.preloader);

		var data = this.images[this.group][this.offset];
		data.src.load(element, {			
			isShowImage: false,
			onComplete:  function (oImage) {
				this.element.removePreloader();
				if (lastWidth  == oImage.width &&
					lastHeight == oImage.height) {
					Effect.MyFade(
						oImage, options.fade
					);
				}else {
					Effect.FoldInMove(
						element, oImage,
						{}, options.effect
					);
				}
				this.last = oImage;
			}.bind(this)  
		});
	},
	
	onClick: function (event, group, src) {
		this.clear();
		var options  = this.options;		
		var hightlight = new HightLight(
			options.hightlight
		);		
		hightlight.show();
		
		var element = this.div(document.body);
		element.setId('Gallery');		
		this.setCenter(element);
		
		var navigation = new GalleryNavigation(
			element, options.navigation
		);
		
		var frame = new GalleryFrame(
			element
		);
		
		var buttonClose = new GalleryClose(
			element, options.buttonClose							
		);
		
		this.element 	 = element;
		this.hightlight  = hightlight;
		this.navigation  = navigation;
		this.frame   	 = frame;
		this.buttonClose = buttonClose;
		this.group   	 = group;
		this.last 	 	 = null;
		
		this.images[this.group].each(function(f, i) {
			if (f.src == src) {this.offset = i; return;}							  
		}.bind(this));
		
		this.go();
		
		if (event) Event.stop(event);
	},
	
	isNextLink: function () {
		return this.offset < this.images[this.group].length - 1;
	},
	
	isPrevLink: function () {
		return this.offset > 0
	},
	
	add: function (options) {
		this.findElements(options.find, options.tag, function(element) {
			element = $(element);
			var rel = element.readAttribute('rel');
			if(rel && (value = rel.match(new RegExp("^"+ options.rel +"(\\[(\\w+)\\])?$")))) {
				group = value[2] ? value[2] : this.group;
				src   = element.readAttribute('href');
				if (!this.images[group]) this.images[group] = [];
				if (!this.images[group].include(src)) {
					this.images[group].push({src: src, group: group});
					if (options.observe) {
						Element.observe(element, 'click', this.onClick.bindAsEventListener(this, group, src));
					}
				}
			}
		}.bind(this));
	},
	
	findElements: function(element, tag, iterator) {
		var child;
		element = $(element);
		var children = (element || document.body).getElementsByTagName(tag);		
		for (var i = 0, length = children.length; i < length; i++) {
			iterator(children[i]);
		}		
	},
	
	setCenter: function (element) {
		var x,y;
		var pageSize   = this.getPageSize();
		var pageScroll = this.getPageScroll();		
		var x = (pageSize[2]  - element.getWidth())  / 2;
		var y = (pageSize[3]  - element.getHeight()) / 2;
		x += pageScroll[0];
		y += pageScroll[1];		
		x = x < 0 ? 5 : x;
		y = y < 0 ? 5 : y;		
		element.setTop(y);
		element.setLeft(x);
		return [x, y];
	},
	
	clear: function () {
		try {
			['Gallery', 'HightLightContainer', 
			 'GalleryBorder', 'GalleryFrLT', 
			 'GalleryFrLB', 'GalleryFrRT', 
			 'GalleryFrRB', 'GalleryClose'
			 ].each(function(e) {
				 $(e).remove();
			});			
		}catch(e) {}	
	},
	
	close: function () {
		Collection.Effect.cancel();
		this.element.remove();		
	}
});
/*  Class GalleryNavigation
/*--------------------------------------------------------------------------*/
var GalleryNavigation = Class.create();

Object.extend(Object.extend(GalleryNavigation.prototype, bsc), {
	initialize: function (element) {
		element = $(element);		
		var options = Object.extend({			
			onPrev: Prototype.emptyFunction,
			onNext:	Prototype.emptyFunction
		}, arguments[1] || {});
		
		var oNavigation    = this.div(element);		
		var oPrevLink 	   = this.a(oNavigation);
		var oNextLink 	   = this.a(oNavigation);
		var oImagePrevLink = this.div(oPrevLink);
		var oImageNextLink = this.div(oNextLink);
		
		oPrevLink.setHref('#');
		oNextLink.setHref('#');
		
		oNavigation.setId('GalleryNavigation');		
		oPrevLink.setId('GalleryPrevLink');		
		oNextLink.setId('GalleryNextLink');
		oImagePrevLink.setId('GalleryImagePrevLink');
		oImageNextLink.setId('GalleryImageNextLink');
		
		this.oPrevLink = oPrevLink;
		this.oNextLink = oNextLink;
		
		Element.observe(oPrevLink, 		'click', options.onPrev.bindAsEventListener(this));
		Element.observe(oImagePrevLink, 'click', options.onPrev.bindAsEventListener(this));
		Element.observe(oNextLink, 		'click', options.onNext.bindAsEventListener(this));
		Element.observe(oImageNextLink, 'click', options.onNext.bindAsEventListener(this));
	},
	
	hidePrevLink: function () {
		this.oPrevLink.hide();	
	},
	
	hideNextLink: function () {
		this.oNextLink.hide();	
	},
	
	showPrevLink: function () {
		this.oPrevLink.show();	
	},
	
	showNextLink: function () {
		this.oNextLink.show();	
	}
});
/*  Class GalleryFrame
/*--------------------------------------------------------------------------*/
var GalleryFrame = Class.create();

Object.extend(Object.extend(GalleryFrame.prototype, bsc), {
	initialize: function (element) {
		element = $(element);
		
		this.x = 0;
		this.y = 0;
		
		var container 	  = document.body;
		var frBorder 	  = this.div(container);
		var frLeftTop 	  = this.div(container);
		var frRightTop 	  = this.div(container);
		var frLeftBottom  = this.div(container);
		var frRightBottom = this.div(container);
				
		frBorder.setId('GalleryBorder');		
		frLeftTop.setId('GalleryFrLT');		
		frRightTop.setId('GalleryFrRT');
		frLeftBottom.setId('GalleryFrLB');
		frRightBottom.setId('GalleryFrRB');
		
		this.frBorder 	   = frBorder;
		this.frLeftTop 	   = frLeftTop;
		this.frRightTop    = frRightTop;
		this.frLeftBottom  = frLeftBottom;
		this.frRightBottom = frRightBottom;
		this.element 	   = element;
		
		this.update();
	},
	
	update: function () {
		var element = this.element;		
		var top     = (this.y || element.getTop()) - 1;
		var left    = (this.x || element.getLeft()) - 1;
		var width   = element.getWidth();
		var height  = element.getHeight();
		
		this.frBorder.setTop(top);
		this.frBorder.setLeft(left);
		this.frBorder.setWidth(width);
		this.frBorder.setHeight(height);
		
		this.frLeftTop.setTop(top);
		this.frLeftTop.setLeft(left);
		
		var dx = dy = 4;
		
		this.frRightTop.setTop(top);
		this.frRightTop.setLeft(left + width - dx);
		
		this.frLeftBottom.setTop(top + height - dy);
		this.frLeftBottom.setLeft(left);
		
		this.frRightBottom.setTop(top + height - dy);
		this.frRightBottom.setLeft(left + width - dx);
		
		this.x = this.y = 0;
	},
	
	setXY: function (x, y) {
		this.x = x;
		this.y = y;
	},
	
	remove: function () {
		this.frBorder.remove();		
		this.frLeftTop.remove();
		this.frRightTop.remove();
		this.frLeftBottom.remove();
		this.frRightBottom.remove();
	}
});
/*  Class GalleryClose
/*--------------------------------------------------------------------------*/
var GalleryClose = Class.create();

Object.extend(Object.extend(GalleryClose.prototype, bsc), {
	initialize: function (element) {
		element = $(element);	
		this.x = this.y = 0;
		
		var options = Object.extend({
			onClose: Prototype.emptyFunction
		}, arguments[1] || {});
		
		this.close = this.div(document.body);
		this.close.setId('GalleryClose');
		
		this.oldTop  = this.close.getTop();
		this.oldLeft = this.close.getLeft();
		
		this.close.hide();
		
		this.element = element;
		this.options = options;
		
		Element.observe(this.close, 'click', this.onClick.bindAsEventListener(this));
	},
	
	update: function () {
		var element = this.element;		
		var top     = (this.y || element.getTop()) - 1;
		var left    = (this.x || element.getLeft()) - 1;
		var width   = element.getWidth();
		var height  = element.getHeight();
		var oldTop  = this.oldTop;
		var oldLeft = this.oldLeft;
		
		this.close.setTop(top + oldTop);
		this.close.setLeft(left + width + oldLeft);
		
		this.x = this.y = 0;
	},
	
	show: function () {
		this.update();
		this.close.show();		
	},
	
	hide: function () {
		this.close.hide();
	},
	
	setXY: function (x, y) {
		this.x = x;
		this.y = y;
	},
	
	onClick: function (event) {
		this.options.onClose();		
		if (event) Event.stop(event);
	},
	
	remove: function () {
		this.close.remove();		
	}
});
/*  Effect
 *  effects.js
/*--------------------------------------------------------------------------*/
if (typeof Collection == 'undefined') {
	Collection = new Object();
}

Collection.Effect = {
	effects: [],	
	add: function (oEffect) {
		this.effects.push(oEffect);
		return oEffect;
	},
	cancel: function () {
		for (var i=0; i < this.effects.length; i++) {			
			this.effects[i].cancel();
		}
		this.effects = [];
	}
};
Effect.FoldInMove = function(element1, element2) {
	element1 = $(element1);
	element2 = $(element2);
	element1.show().makeClipping().makePositioned();
	var options = Object.extend({		
		durationX:   0.5,
		durationY:   0.7
	}, arguments[2] || {});
	
	var options_for_x = Object.extend({
		start:  Prototype.emptyFunction,
		update: Prototype.emptyFunction,
		end:    Prototype.emptyFunction
	}, (arguments[3] ? arguments[3].x : false) || {});
	
	var options_for_y = Object.extend({
		start:  Prototype.emptyFunction,
		update: Prototype.emptyFunction,
		end:    Prototype.emptyFunction
	}, (arguments[3] ? arguments[3].y : false) || {});
	
	var width  		= element2.offsetWidth  || element2.width;
	var height 		= element2.offsetHeight || element2.height;
	var top    		= element1.offsetTop;
	var left   		= element1.offsetLeft;	
	var startWidth  = element1.offsetWidth;
	var startHeight = element1.offsetHeight;
	
	if ( (startWidth % 2  && !(width % 2)) ||
	   (!(startWidth % 2) && width % 2)) {
		width--;   
	}	
	if ( (startHeight % 2  && !(height % 2)) ||
	   (!(startHeight % 2) && height % 2)) {
		height--;   
	}
	
	var moveX = (width  - startWidth ) / 2;
	var moveY = (height - startHeight) / 2;
	
	var scaleFromX = ((startWidth)  * 100) / width;
	var scaleFromY = ((startHeight) * 100) / height;
	
	var endX = left - moveX;
	var endY = top  - moveY;
	
	if (endX < 0) moveX += endX - 5;
	if (endY < 0) moveY += endY - 5;
	
	return new Effect.Parallel(
		[ Collection.Effect.add(new Effect.Scale(element1, 100, {
			scaleX: 		 true, 
			scaleY: 		 false, 
			scaleFrom: 		 scaleFromX,
			scaleContent: 	 false, 
			scaleFromCenter: false,
			scaleMode: 		 {originalWidth: width},
			sync: 			 true
		  })),
		  Collection.Effect.add(new Effect.Move(element1, {
		  	x:    -moveX, 
			y: 	  0, 
			sync: true			
		  })),
		  Collection.Effect.add(new Effect.Move(element2, {
		  	x:    moveX, 
			y:	  0,
			sync: true
		  }))
		],
		Object.extend({
			duration: options.durationX,
			restoreAfterFinish: true,
			beforeSetup: function (effect) {				
				Position.absolutize(effect.effects[2].element);				
				effect.effects[2].element.setStyle({
					top:  -moveY + 'px',
					left: -moveX + 'px'
				});				
				Position.absolutize(effect.effects[0].element);				
				options_for_x.start(effect);				
			},
			afterUpdateInternal: function(effect) {
				options_for_x.update(effect);
			},			
			afterFinishInternal: function(effect) {
				options_for_x.end(effect);
				//start Y
				new Effect.Parallel(
					[ Collection.Effect.add(new Effect.Scale(effect.effects[0].element, 100, {
						scaleX: 		 false, 
						scaleY: 		 true, 
						scaleFrom: 		 scaleFromY,
						scaleContent: 	 false, 
						scaleFromCenter: false,
						scaleMode: 		 {originalHeight: height},
						sync: 			 true
					  })),
					  Collection.Effect.add(new Effect.Move(effect.effects[0].element, {
						x:    0, 
						y: 	  -moveY, 
						sync: true
					  })),
					  Collection.Effect.add(new Effect.Move(effect.effects[2].element, {
						x: 	  0, 
						y:	  moveY,
						sync: true						
					  }))
					],
					Object.extend({
						duration: options.durationY,
						beforeSetup: function (effect) {
							options_for_y.start(effect);
						},
						afterUpdateInternal: function(effect) {
							options_for_y.update(effect);
						},
						afterFinishInternal: function(effect) {
							/*effect.effects[0].element.undoClipping();*/
							options_for_y.end(effect);
						}
					})
				);
				//end Y
			}
		})
	);
};
Effect.MyFade = function(element) {
	element = $(element);	
	var options = Object.extend({
	from: 0.0,
	to:   1.0,
	duration: 0.8
	}, arguments[1] || {});
	return new Effect.Opacity(element,options);
};
Effect.MyFadeBg = function(obj, element, imageUrl) {	
	var oldOpacity = element.getInlineOpacity();
	var options = Object.extend({
		from: 1.0,
		to:   0.0,
		afterFinishInternal: function(effect) {			
			obj.showBackground(
				effect.element, 
				imageUrl
			).setStyle({opacity: oldOpacity});
			obj.toStartTimeCounter(obj.interval);
	}}, {});
	return new Effect.Opacity(element,options);
};
/*  Object ProductGallery
/*--------------------------------------------------------------------------*/
var ProductGallery = new Object();

Object.extend(Object.extend(ProductGallery, bsc), {
	showImage: function (event, element) {		
		var fr = this.getElementFr(element);
		if (!this.isCurrentElement(fr)) {
			var image = $("product_big_image");
			var parent = $(image.parentNode);
			var ref = $(this.getReference(image));
			parent.makePositioned();
			this.hide(image);
			parent.removePreloader();
			parent.setPreloader('/f/ajaxa_loader.gif');
			(new ExImage(false, {
				src: this.attr(element, "image_url"),
				onComplete: function (object) {					
					parent.removePreloader();
					image.setSrc(object.src);
					ref.setHref(this.attr(element, 'href'));
					this.show(image);
				}.bind(this)
			}));					
			this.setCurrentElement(fr);			
		}
		if (event) Event.stop(event);
	},
	
	hideFr: function (event, element) {
		var element = this.getElementFr(element);
		if (!this.isCurrentElement(element)) {
			this.hide(element);
		}
		if (event) Event.stop(event);
	},

	showFr: function (event, element) {		
		var element = this.getElementFr(element);
		if (!this.isCurrentElement(element)) {
			this.show(element);
		}
		if (event) Event.stop(event);
	},
	
	getElementFr: function (element) {
		return element.getElementsByTagName("IMG")[1];
	},
	
	setCurrentElement: function (element) {
		var current = $('current_element');					
		if (current) {
			current.removeAttribute('id');
			this.hide(current);
		}
		element.setAttribute('id', 'current_element');		
	},
	
	isCurrentElement: function (element) {
		return this.hasAttributeValue(element, "id", "current_element");
	},
	
	getReference: function (element) {
		return 	element.parentNode.getElementsByTagName('a')[0];
	}
});
/*  Object SwitchFadeImages
/*--------------------------------------------------------------------------*/
var SwitchFadeImages = {
	preloader: 				  null,
	onFirstImageLoadComplete: Prototype.emptyFunction,	
	beforeFirstImageLoad: 	  Prototype.emptyFunction,
	
	init: function (main, container, url) {
		this.main = $(main);
		this.container = $(container);		
		this.options = {};
		this.options.image = [];
		this.counter = 1;
		this.interval = 6;
				
		for (i in url) {
			var index = this.options.image.push({
				obj: new Image(),
				url: url[i],
				success: 0
			}) - 1;
			this.setOnLoadEvent(
				this.options.image[index].obj,
				index
			);
		}
		this.loadFirstImage();
	},
	
	loadFirstImage: function () {
		this.beforeFirstImageLoad();
		this.load(
			{i1: this.options.image[0]},
			function (images) {
				this.showBackground(
					this.container, 
					images.i1.obj.src					
				);
				this.onFirstImageLoadComplete(images.i1);
				this.toStartTimeCounter();
			}.bind(this)
		);
	},
	
	toStartTimeCounter: function () {
		if (this.options.image.length > 1) this.execute(this.toStartEffect.bind(this), this.interval);
	},
	
	toStartEffect: function (executer) {		
		this.load(
			{i1: this.options.image[this.counter++]},
			function (images) {				
				this.showEffect(
					this.main, 
					this.container, 
					images.i1.obj.src
				);			
				this.resetCounter(
					"counter",
					this.options.image.length - 1,
					0
				);
			}.bind(this)
		);
		executer.stop();
	},
	
	showEffect: function (main, container, imageUrl) {		
		this.setOpacity(container, 1);		
		this.showBackground(this.main, imageUrl);
		Effect.MyFadeBg(this, container, imageUrl);		
	},
	
	isComplete: function (obj) {
		return 	obj.success == 1;
	},
	
	load: function (images, onComplete) {		
		for (i in images) {
			if (images[i] && !images[i].obj.src) {				
				images[i].obj.src = images[i].url;
			}
		}
		this.execute(function (executer) {
			var counterTrue = 0;
			var count = 0;
			for (i in images) {
				if (images[i] && this.isComplete(images[i])) {
					counterTrue++;	
				}
				count++;
			}
			if (count == counterTrue) {
				onComplete(images); 
				executer.stop();
			}
		}.bind(this), 0.01);
	},
	
	resetCounter: function (counter, length, value) {
		if (this[counter] > length) this[counter] = value;
	},
	
	onComplete: function (event, objIndex) {		
		this.options.image[objIndex].success = 1;
		Event.stop(event);
	},
	
	execute: function (callback, time) {
		return new PeriodicalExecuter (callback, time);
	},
	
	timer: function (callback, time) {
		this.execute(function (executer) {
			callback();
			executer.stop();				   
		}, time);
	},
	
	setOnLoadEvent: function (element, objIndex) {
		Element.observe(element, 'load', this.onComplete.bindAsEventListener(this, objIndex));		
	},
	
	show: function (element) {
		Element.setStyle(element, {visibility:"visible"});
	},
	
	hide: function (element) {
		Element.setStyle(element, {visibility:"hidden"});
	},
	
	hideBackground: function (element) {
		Element.setStyle(element, {background:"none"});
	},
	
	showBackground: function (element, url) {
		return url
		? Element.setStyle(element, {background:"url(" + url + ") no-repeat center"})
		: element;		
	},
	
	setOpacity: function (element, value) {
		element.setStyle({opacity:value});
		element.setStyle({filter:"progid:DXImageTransform.Microsoft.Alpha(opacity=" + value*100 + ")"});		
	},
	
	createPreloader: function (element, preloaderContent) {
		var div = document.createElement('div');		
		element.appendChild(div);				
		div.innerHTML = preloaderContent;
		Element.setStyle(div, {position:"absolute"});					
		Element.setStyle(div, {top: (element.offsetHeight - div.offsetHeight) /2 + "px"});
		Element.setStyle(div, {left: (element.offsetWidth - div.offsetWidth) /2 + "px"});
		Element.setStyle(div, {visibility:"visible"});		
		return div;
	},
	
	removePreloader: function () {
		Element.remove(this.preloader);		
	}
};
/*  Class SubMenu
/*--------------------------------------------------------------------------*/
var SubMenu = Class.create();

Object.extend(SubMenu.prototype, {
	initialize: function () {
		this.timer  	 			= null;
		this.lastContainer 			= null;
		this.lastSubContainer 		= null;
		this.lastItem 	 		   	= null;		
		
		var options = Object.extend({
			container: null,
			tag:	  'a',
			side:     'bottom',
			rel:	  'SubMenu',
			delay: 	  0.5,
			subItem:  false
		}, arguments[0] || {});
		
		this.options = options;
		
		this.setup(options);
	},
	
	setup: function (options) {
		Element.observe(window, 'unload', function () {
			delete this;
		}.bind(this));		
		this.findObjects(options);
	},
	
	findElements: function(element, tag, iterator) {
		var child;
		element = $(element);
		var children = (element || document.body).getElementsByTagName(tag);		
		for (var i = 0, length = children.length; i < length; i++) {
			iterator(children[i]);
		}		
	},
	
	findObjects: function (options) {		
		this.findElements(options.container, options.tag, function(element) {
			element = $(element);
			var rel = element.readAttribute('rel');
			if(rel && rel.match(new RegExp("^"+ options.rel +"$"))) {
				var target = element.next(0);
				if (target) {
					target.hide();
					target.className = $w(target.classNames().toString())[0];
					Element.observe(
						element, 'mouseover', 
						this.onOver.bindAsEventListener(this, element, target)
					);
					Element.observe(
						element, 'mouseout', 	
						this.onOut.bindAsEventListener(this, element, target)
					);									
					Element.observe(
						target, 'mouseover', 
						this.onOverContainer.bindAsEventListener(this, element, target)
					);
					Element.observe(
						target, 'mouseout', 	
						this.onOutContainer.bindAsEventListener(this, element, target)
					);
					
					if (this.options.subItem) {
						$A(target.immediateDescendants()).each(function (ele) {
							if (ele.tagName.toLowerCase() == 'a') {
								var div = ele.next('div');								
								if (div) {
									div.hide();
									div.className = $w(div.classNames().toString())[0];

									Element.observe(
										ele, 'mouseover', 
										this.onOverItem.bindAsEventListener(this, ele, div)
									);
									Element.observe(
										ele, 'mouseout', 	
										this.onOutItem.bindAsEventListener(this, ele, div)
									);
								}
							}
						}.bind(this));
					}
				}
			}
		}.bind(this));		
	},
	
	showTarget: function (source, target) {		
		$(source.parentNode).makePositioned();
		var sourceTop    = source.getTop();
		var sourceLeft   = source.getLeft();
		var sourceWidth  = source.getWidth();
		var sourceHeight = source.getHeight();
		var targetHeight = target.getDimensions().height;
		var targetWidth  = parseInt(target.getStyle('width') || 0);
		
		target.setWidth(targetWidth || sourceWidth);
		target.setHeight(targetHeight);
		
		switch (this.options.side) {
			case "top":				
				target.setTop(sourceTop - targetHeight);
			break;
			case "bottom": 
				target.setTop(sourceTop + sourceHeight);
			break;			
		}
		target.show();
	},
	
	onOver: function (event, source, target) {		
		this.hideLastSubContainer();
		this.setClassNameToLastItem();
		
		this.stopTimer();
		this.hideLastContainer();
		
		this.showTarget(source, target);
	},
	
	onOut: function (event, source, target) {		
		this.timer = new PeriodicalExecuter(function(executer) {
			this.hideLastSubContainer();
			this.setClassNameToLastItem();
			
			$(source.parentNode).undoPositioned();
			target.hide();
			executer.stop();
		}.bind(this), this.options.delay);
		
		this.setLastContainer(target);
	},
	
	onOverContainer: function (event, source, target) {
		this.stopTimer();
	},
	
	onOutContainer: function (event, source, target) {
		this.onOut(event, source, target);		
	},
	
	onOverItem: function (event, source, target) {
		var dimensions 		   = target.getDimensions();
		var targetHeight 	   = dimensions.height;
		var targetWidth 	   = dimensions.width;
		var sourceTop 		   = source.getTop();
		var parentSourceHeight = source.parentNode.getHeight();
		var dy = 0;
		
		this.hideLastSubContainer();
		this.setClassNameToLastItem();
		
		if (targetHeight > (parentSourceHeight - sourceTop)) {
			dy = targetHeight - (parentSourceHeight - sourceTop);			
		}
		if (this.lastElement(source.parentNode)) {			
			if (browser.is_ie) targetWidth += 1;
			target.setStyle({right: (targetWidth + 1).px()});
		}
		target.setHeight(targetHeight);
		target.setTop(source.getTop() - dy);
		source.className = 'item_hover';
		target.show();
	},
	
	onOutItem: function (event, source, target) {
		this.setLastItem(source);
		this.setLastSubContainer(target);
	},
	
	lastElement: function (element) {
		return element.readAttribute('last') !== null;
	},
	
	stopTimer: function () {
		if (this.timer) this.timer.stop();
		this.timer = null;
	},
	
	setLastContainer: function (element) {
		this.lastContainer = element;
	},
	
	hideLastContainer: function () {
		if (this.lastContainer) this.lastContainer.hide();
		this.lastContainer = null;
	},
	
	setLastSubContainer: function (element) {
		this.lastSubContainer = element;
	},
	
	hideLastSubContainer: function () {
		if (this.lastSubContainer) this.lastSubContainer.hide();
		this.lastSubContainer = null;
	},
	
	setLastItem: function (element) {
		this.lastItem = element;
	},
	
	setClassNameToLastItem: function () {
		if (this.lastItem) {
			this.lastItem.className = 'item';
		}
		this.lastItem = null;
	}
});
/*  Class Informer
/*--------------------------------------------------------------------------*/
var Informer = Class.create();

Informer.prototype = {
	initialize: function () {
		var options = Object.extend({
			container: 	document.body,
			position:	'center',
			showTime:   0.7
		}, arguments[0] || {});
	
		this.element = null;
		this.message = null;
		this.effect = null;
		this.timer = null;
		this.container = $(options.container);		
		this.options = options;
		
		this.drawHidden();
	},
	
	drawHidden: function () {
		var div = bsc.div(this.container);
		div.hide().addClassName('informer');
		
		bsc.div(div).addClassName('informer-bgr');
		
		var message = bsc.div(div);
		message.addClassName('informer-message');
		
		this.setPosition(div);
		this.element = div;
		this.message = message;
	},
	
	hide: function () {
		if (this.element) this.element.hide();
	},
	
	show: function (message) {
		if (!this.element) return;
		this.cancelEffect();
		this.stopTimer();		
		bsc.setOpacity(this.element, 1);
		this.updateMessage(message);		
		this.element.show();		
		this.setTimer(this.showEffect.bind(this));
	},
	
	showError: function (message) {
		this.show('<span style="color:#ff0000;">'+ message +'</span>');
	},
	
	updateMessage: function (message) {
		if (this.message) {
			this.message.update(message);
			if (this.element) {
				if (this.element.getStyle('display') == 'none') {
					bsc.hide(this.element).show();
					this.setCenter(this.element, this.message);
					bsc.show(this.element.hide());
				}else {
					this.setCenter(this.element, this.message);
				}
			}			
		}		
	},
	
	showEffect: function () {
		if (!this.element) return;		
				
		this.effect = Effect.MyFade(this.element, {
			from: 	  1.0,
			to:   	  0.0,
			duration: 0.8,
			beforeSetup: function (effect) {									
				/* effect.element.show(); */
			},
			afterFinishInternal: function(effect) {		
				effect.element.hide();
			}
		});
	},
	
	cancelEffect: function () {
		if (this.effect) {
			this.effect.cancel();
			this.effect = null;
		}
	},
	
	setTimer: function (callback) {
		this.timer = bsc.execute(function (timer) {
			if (callback) callback();
			timer.stop();
		}, this.options.showTime);
	},
	
	stopTimer: function () {
		if (this.timer) {
			this.timer.stop();
			this.timer = null;
		}
	},
	
	setPosition: function (element) {
		switch (this.options.position) {
			case 'center':
				bsc.hide(element).show();
				this.setCenter(this.container, element);
				bsc.show(element.hide());
				break;
		}
		
	},
	
	setCenter: function (container, element) {		
		element.setTop((container.getHeight() - element.getHeight()) / 2);
		element.setLeft((container.getWidth() - element.getWidth()) / 2);		
	}
}
/*  Class XMLParser
/*--------------------------------------------------------------------------*/
var XMLParser = Class.create();

XMLParser.prototype = {
	initialize: function () {		
	},
	
	parseFromString: function (string) {
		return Try.these(
			function() {
				var xmldoc = new ActiveXObject('Microsoft.XMLDOM');					
				xmldoc.loadXML(string);
				return xmldoc;
			},
			function() {
				var parser = new DOMParser();
				xmldoc = parser.parseFromString(string, "text/xml");
				return xmldoc;
			}
		) || false;
	}
}

String.prototype.px = function () {
	return this + 'px';
}
String.prototype.load = function (container) {
	if (/\.(gif|jpg|png)$/.test(this)) {
		return (new ExImage(container, Object.extend({
				src: this
				}, arguments[1] || {}))
		).image
	}
	return false;
}
Number.prototype.px = function () {
	return this + 'px';
}
Number.prototype.round = function (precision) {	
	var factor = (precision == 0) ? 1 : Math.pow(10, precision);
    return Math.round(this * factor) / factor;	
}

Element.addMethods({
	getWidth: function (element) {
	   	element = $(element);
	   	return element.offsetWidth; 
	},
	
	getHeight: function (element) {
	   	element = $(element);
	   	return element.offsetHeight; 
	},
	
	getTop: function (element) {
	   	element = $(element);
	   	return element.offsetTop; 
	},
	
	getLeft: function (element) {
	   	element = $(element);
	   	return element.offsetLeft; 
	},
	
	getOpacity: function (element) {
	   	element = $(element);
	   	return element.getStyle('opacity'); 
	},
	
	setWidth: function (element, w) {
	   	element = $(element);
    	element.setStyle({width: w.px()});
		return element;
	},
	
	setHeight: function (element, h) {
   		element = $(element);
    	element.setStyle({height: h.px()});
		return element;
	},
	
	setTop: function (element, t) {
	   	element = $(element);
		element.setStyle({top: t.px()});
		return element;
	},
	
	setLeft: function (element, l) {
	   	element = $(element);
		element.setStyle({left: l.px()});
		return element;
	},
	
	setHref: function (element, href) {
	   	element = $(element);
		element.setAttribute('href', href);
		return element;
	},
	
	setId: function (element, id) {
	   	element = $(element);
		element.setAttribute('id', id);
		return element;
	},
	
	setSrc: function (element, src) {
	   	element = $(element);
		if (src) element.src = src;
		return element;
	},
	
	setCenter: function (element, w, h) {
		element = $(element);
		Position.absolutize(element);	
		var y = (h  - element.getHeight()) / 2;
		var x = (w  - element.getWidth())  / 2;
		y = y < 0 ? 5 : y;
		x = x < 0 ? 5 : x;
		element.setTop(y);
		element.setLeft(x);
		return element;
	},
	
	setPreloader: function (element, content) {
		element = $(element);		
		element._preloader = bsc.createPreloader(			
			element,
			content,
			true
		);
		return element;
	},
	
	removePreloader: function (element) {
		element = $(element);
		if (element._preloader) {
			element._preloader.remove();
			element._preloader = undefined;
		}
		return element;
	}
});