/**
	*	Salute javascript gallery v2.6.1
	*	© 2011 Aleksey Zabrodin (drvhart@ya.ru)
	*/
	
	var Salute = {
		
		Options: {
			
			globalPath: '',
			
			loadingImg: 'img/loading.gif',
			
			errorImg: 'img/error.gif',
			
			resizeMode: true,
			
			blindOpacity: '70',
			
			controlOpacity: '70',
			
			loadingTimeout: 15
			
		},
		
		Lang: {
			
			close: 'Закрыть',
			
			next: 'Следующая',
			
			prev: 'Предыдущая'
			
		},
		
		Style: {
			
			blind: {
				backgroundColor: '#000', width: '100%', height: '100%', display: 'none',
				position: 'absolute', top: '0', left: '0', zIndex: '100'
			},
			
			container: {
				background: "#fff url('%image%') no-repeat center center", padding: '10px',
				display: 'none', position: 'absolute', top: '0', left: '0', zIndex: '101'
			},
			
			control: {
				backgroundColor: '#fff', fontSize: '13px', fontFamily: 'Arial, Helvetica, sans-serif',
				color: '#000', margin: '10px', padding: '7px 9px', display: 'none', position: 'absolute',
				top: '10px', zIndex: '102'
			},
			
			move: {
				left: '10px'
			},
			
			close: {
				right: '10px'
			},
			
			link: {
				backgroundColor: '#fff', color: '#000', outline: 'none', textDecoration: 'underline'
			},
			
			lockLink: {
				backgroundColor: '#fff', color: '#aaa', outline: 'none', textDecoration: 'none'
			},
			
			span: {
				color: '#000'
			},
			
			lockSpan: {
				color: '#aaa'
			}
			
		},
		
		Tools: {
			
			list: function(object, callBack)
			{
				for (var i = 0; i < object.length; i++)
				{
					callBack.call(object, object[i], i);
				}
			},
			
			hide: function()
			{
				this.list(arguments, function(element)
				{
					element.style.display = 'none';
				});
			},
			
			show: function()
			{
				this.list(arguments, function(element)
				{
					element.style.display = '';
				});
			},
			
			event: function(object, eventName, callBack)
			{
				var self = this, shell = function(event)
				{
					callBack.call(object, event);
				};
				
				this.list(eventName.split('|'), function(value)
				{
					object.attachEvent ? object.attachEvent('on' + value, shell) :
						object.addEventListener(value, shell, false);
				});
			},
			
			agent: function(name)
			{
				return new RegExp(name, 'i').test(navigator.userAgent);
			},
			
			set: function (object, param)
			{
				for (var i in param)
				{
					object[i] = param[i];
				}
			},
			
			style: function(element, style)
			{
				this.set(element.style, style);
			},
			
			opacity: function(element, value)
			{
				if (this.agent('msie'))
				{
					element.style.filter = (value == 100) ? null : 'alpha(opacity=' + value + ')';
				}
				else
				{
					element.style.opacity = (value / 100);
				}
			},
			
			shadow: function(element, value)
			{
				if (!this.agent('msie'))
				{
					this.style(element, {
						boxShadow: value, MozBoxShadow: value, webkitBoxShadow: value
					});
				}
			},
			
			loop: function(value, time, step, callBack)
			{
				
				if (this.agent('mobile'))
				{
					callBack.call(null, value, value);
				}
				else
				{
					var count = 0, total = step * Math.round(value / step), i;
				
					i = setInterval((function()
					{
						count > total ? clearInterval(i) :
							callBack.call(null, Math.round(count / total * value), value);
						count += step;
						
						return arguments.callee;
						
					})(), time);
				}
			},
			
			fade: function(element, time, step)
			{
				var self = this;
				
				self.loop(100, time, step, function(value)
				{
					self.opacity(element, value);
				});
			},
			
			createNode: function(parent, nodeName, param, style)
			{
				var element = document.createElement(nodeName);
				
				if (param)
				{
					this.set(element, param);
				}
				
				if (style)
				{
					this.style(element, style);
				}
					
				return parent.appendChild(element);
			},
			
			varExport: function(object, name)
			{
				var output = [];
				
				for (var i in object)
				{
					output.push(i + '=' + name + '.' + i);
				}
				
				return 'var ' + output.join(',') + ';';
			}
			
		},
		
		Elements: {},
		
		Collection: {},
		
		System: {},
		
		Init: function()
		{
			eval(Salute.Tools.varExport(Salute, 'Salute'));
			
			if (!Options.globalPath)
			{
				Tools.list(document.getElementsByTagName('script'), function(element)
				{
					if (/salute\.js/i.test(element.src))
					{
						Options.globalPath = element.src.replace(/salute\.js/i, '');
					}
				});
			}
			
			var index;
			
			Tools.list(document.getElementsByTagName('a'), function(element)
			{
				if (element.href && /^salute/i.test(element.rel))
				{
					if (!Collection[element.rel])
					{
						Collection[element.rel] = [];
						
						index = 0;
					}
					
					Collection[element.rel].push(element);
					
					Tools.set(element, {
						index: index, onclick: show
					});
					
					index++;
				}
			});
			
			/*
			*	Elements
			*/
			Elements.blind = Tools.createNode(document.body, 'div', {
				onclick: hide
			}, Style.blind);
			
			Tools.opacity(Elements.blind, Options.blindOpacity);
			
			Style.container.background = 
				Style.container.background.replace('%image%', Options.globalPath + Options.loadingImg);
			
			Elements.container = Tools.createNode(document.body, 'div', null, Style.container);
			
			Tools.shadow(Elements.container, '0 1px 5px rgba(0, 0, 0, 0.7)');
			
			Elements.img = Tools.createNode(Elements.container, 'img', {
				src: Options.globalPath + Options.loadingImg
			});
			
			Elements.move = Tools.createNode(Elements.container, 'div', null, Style.control);
			Tools.style(Elements.move, Style.move);
			
			Elements.close = Tools.createNode(Elements.container, 'div', null, Style.control);
			Tools.style(Elements.close, Style.close);
			
			Tools.list([Elements.move, Elements.close], function(element)
			{
				Tools.opacity(element, Options.controlOpacity);
			});
			
			Elements.prevSpan = Tools.createNode(Elements.move, 'span', {
				innerHTML: '&larr;&nbsp;'
			});
			
			Elements.prevLink = Tools.createNode(Elements.move, 'a', {
				href: 'javascript:;', innerHTML: Lang.prev, onclick: function()
				{
					show('prev');
				}
			});
			
			Elements.midSpan = Tools.createNode(Elements.move, 'span', {
				innerHTML: '&nbsp;&nbsp;&nbsp;'
			});
			
			Elements.nextLink = Tools.createNode(Elements.move, 'a', {
				href: 'javascript:;', innerHTML: Lang.next, onclick: function()
				{
					show('next');
				}
			});
			
			Elements.nextSpan = Tools.createNode(Elements.move, 'span', {
				innerHTML: '&nbsp;&rarr;'
			});
			
			Elements.closeLink = Tools.createNode(Elements.close, 'a', {
				href: 'javascript:;', innerHTML: Lang.close, onclick: hide
			}, Style.link);
			
			/*
			*	Control events
			*/
			if (Tools.agent('mobile'))
			{
				Tools.event(Elements.img, 'click', function(event)
				{
					show(this.width / 2 < event.offsetX ? 'next' : 'prev');
				});
			}
			else
			{
				Elements.img.onmouseout = function()
				{
					Tools.hide(Elements.move, Elements.close);
				};
				
				Elements.img.onmousemove = function()
				{
					Elements.close.onmouseover();
					
					if (Elements.close.timer)
					{
						clearTimeout(Elements.close.timer);
					}
					
					Elements.close.timer = setTimeout(Elements.img.onmouseout, 1000);
				};
				
				Elements.move.onmouseover = Elements.close.onmouseover = function()
				{
					if (Elements.container.clientWidth > 100)
					{
						if (Elements.close.timer)
						{
							clearTimeout(Elements.close.timer);
						}
						
						Tools.show(Elements.close);
						
						if (Collection[System.rel] && Collection[System.rel].length > 1)
						{
							Tools.show(Elements.move);
						}
					}
				};
			}
			
			Tools.event(window, 'resize|scroll', function()
			{
				if (Elements.container.style.display != 'none')
				{
					setTimeout(resize, 10);
				}
			});
			
			Tools.event(document, 'keyup', function(event)
			{
				if (Elements.blind.style.display != 'none')
				{
					switch (event.keyCode)
					{
						case 37: show('prev');
						break;
						
						case 39: show('next');
						break;
						
						case 27: hide();
					}
				}
			});
			
			function resize(reset)
			{
				var maxWidth = Elements.blind.clientWidth, maxHeight = Elements.blind.clientHeight,
					imgWidth = System.temp.width, imgHeight = System.temp.height;
					
				Elements.img.width = imgWidth;
	          	Elements.img.height = imgHeight;
	          	
				if (Options.resizeMode)
				{	
	          		if (Elements.img.width + 40 > maxWidth)
					{
						Elements.img.width = maxWidth - 40;
						Elements.img.height = (Elements.img.width * imgHeight) / imgWidth;
					}
					
					if (Elements.img.height + 40 > maxHeight)
					{
						Elements.img.height = maxHeight - 40;
						Elements.img.width = (Elements.img.height * imgWidth) / imgHeight;
					}
				}
				
				align(true);
				
				if (!reset)
				{
					resize(true);
				}
			}
			
			function align(reset)
			{
				var top = document.documentElement.scrollTop || document.body.scrollTop;
				
				Elements.blind.style.top = top + 'px';
				
				Tools.style(Elements.container, {
					top: (Elements.blind.clientHeight / 2 - Elements.container.clientHeight / 2) + top + 'px',
					left: (Elements.blind.clientWidth / 2 - Elements.container.clientWidth / 2) + 'px'
				});
				
				if (!reset)
				{
					align(true);
				}
			}
			
			function show(move)
			{
				if (move == 'prev' || move == 'next')
				{
					if (move == 'prev' && System.index > 0)
					{
						System.index--;
					}
					else if (move == 'next' && System.index < Collection[System.rel].length - 1)
					{
						System.index++;
					}
					else
					{
						return false;
					}
				}
				else
				{
					Tools.set(System, {
						rel: this.rel, index: this.index
					});
				}
				
				Tools.list([Elements.prevLink, Elements.nextLink], function(element)
				{
					Tools.style(element, Style.link);
				});
				
				Tools.list([Elements.prevSpan, Elements.nextSpan], function(element)
				{
					Tools.style(element, Style.span);
				});
				
				if (!System.index)
				{
					Tools.style(Elements.prevLink, Style.lockLink);
					Tools.style(Elements.prevSpan, Style.lockSpan);
				}
				else if (System.index == Collection[System.rel].length - 1)
				{
					Tools.style(Elements.nextLink, Style.lockLink);
					Tools.style(Elements.nextSpan, Style.lockSpan);
				}
				
				/**
				*	Show gallery
				*/
				Tools.show(Elements.blind, Elements.container);
				Tools.opacity(Elements.img, 0);
				
				align();
				
				if (System.tid)
				{
					clearTimeout(System.tid);
				}
				
				System.tid = setTimeout(function()
				{
					var error = new Image();
					
					error.src = Options.globalPath + Options.errorImg;
					
					System.temp.src = error.src;
					
					clearTimeout(System.tid);
					
				}, Options.loadingTimeout * 1000);
				
				Tools.set(System.temp = new Image(), {
					src: Collection[System.rel][System.index], onload: function()
					{
						Elements.img.src = System.temp.src;
				
						resize();
				
						Tools.fade(Elements.img, 20, 10);
						
						clearTimeout(System.tid);
					}
				});
				
				return false;
			}
			
			function hide()
			{
				Tools.hide(Elements.blind, Elements.container);
				
				Elements.img.onmouseout();
			}
		}
	}
	
	Salute.Tools.event(window, 'load', function()
	{
		Salute.Init();
	});