/**
 * Sticky
 * @author Jeffrey van der Veen
 */
var Sticky = function(options) {this.init(options);};

Sticky.prototype =
{
	/**
	 * Constructor
	 * @param	object options
	 * @return	void
	 */
	init: function(options)
	{
		this.options = {
			selector: '[data-sticky]'
		};
		
		$.extend(this.options, options);
		
		this.window			= $(window);
		this.viewport_node	= $('#viewport');
		this.scroll_node	= $();
		this.page_node		= $();
		this.sticky_nodes	= $();
		
		this.sticky_support	= false;
		this.sticky_heights	= [];
		this.sticky_tops	= [];
		
		this.start();
	},
	
	/**
	 * Start
	 * @return void
	 */
	start: function()
	{
		this.scroll_node	= this.viewport_node.css('overflow') == 'visible' ? this.window : this.viewport_node;
		this.sticky_nodes	= $(this.options.selector);
		
		if (this.sticky_nodes.length) {
			this.sticky_support = this.sticky_nodes.first().css('position').match('sticky');
			
			if (this.sticky_support) {
				this.initSticky();
			} else {
				this.page_node = this.sticky_nodes.first().parents('.page:first');
				
				this.setStickyData();
				this.setSticky();
				this.setStickySize();
			}
			
			this.setEvents();
		}
	},
	
	/**
	 * Set events
	 * @return void
	 */
	setEvents: function()
	{
		var _this = this;
		
		if (this.sticky_support) {
			this.window.resize(function() {
				_this.initSticky();
			});
		} else {
			this.scroll_node.scroll(function() {
				_this.setSticky();
				_this.setStickySize();
			});
			
			this.window.resize(function() {
				_this.setStickyData();
				_this.setSticky();
				_this.setStickySize();
			});
		}
	},
	
	/**
	 * Init sticky
	 * @return void
	 */
	initSticky: function()
	{
		var sticky_heights = 0;
		
		this.sticky_nodes.each(function() {
			var sticky_node = $(this);
			
			if (sticky_heights) {
				sticky_node.css('top', sticky_heights);
			}
			
			sticky_heights += sticky_node.outerHeight();
		});
	},
	
	/**
	 * Set sticky data
	 * @return void
	 */
	setStickyData: function()
	{
		var _this = this;
		
		this.sticky_heights	= [];
		this.sticky_tops	= [];
		
		this.sticky_nodes.each(function() {
			var sticky_node	= $(this);
			var is_sticky	= sticky_node.hasClass('sticky');
			
			if (is_sticky) {
				var ghost_node = sticky_node.next('.ghost');
				
				sticky_node.removeClass('sticky').css('top', '');
				ghost_node.css('height', '');
			}
			
			if (sticky_node.is(':visible')) {
				var sticky_height	= sticky_node.outerHeight(true);
				var sticky_top		= sticky_node.offset().top;
			} else {
				var sticky_height	= 0;
				var sticky_top		= 0;
			}
			
			_this.sticky_heights.push(sticky_height);
			_this.sticky_tops.push(sticky_top);
		});
	},
	
	/**
	 * Set sticky
	 * @return void
	 */
	setSticky: function()
	{
		var _this		= this;
		var scroll_top	= this.scroll_node.scrollTop();
		
		this.sticky_nodes.each(function(index) {
			var sticky_node		= $(this);
			var sticky_height	= _this.sticky_heights[index];
			var sticky_top		= _this.sticky_tops[index];
			var sticky_nodes	= sticky_node.prevAll('.sticky');
			var sticky_heights	= 0;
			var ghost_node		= sticky_node.next('.ghost');
			var is_sticky		= sticky_node.hasClass('sticky');
			
			if (sticky_nodes.length) {
				sticky_nodes.each(function() {
					sticky_heights += $(this).outerHeight();
				});
				
				sticky_top -= sticky_heights;
			}
			
			if (!is_sticky && sticky_top <= scroll_top) {
				sticky_node.addClass('sticky');
				
				if (sticky_heights) {
					sticky_node.css('top', sticky_heights);
				}
				
				if (!ghost_node.length) {
					ghost_node = $('<div>', {class: 'ghost'});
					
					sticky_node.after(ghost_node);
				}
				
				ghost_node.css('height', sticky_height);
			} else if (is_sticky && sticky_top > scroll_top) {
				sticky_node.removeClass('sticky').css('top', '');
				
				ghost_node.css('height', '');
			}
		});
	},
	
	/**
	 * Set sticky size
	 * @return void
	 */
	setStickySize: function()
	{
		if (!this.viewport_node.is('body')) {
			var scroll_width	= this.scroll_node.outerWidth();
			var page_width		= this.page_node.outerWidth();
			
			this.sticky_nodes.each(function() {
				var sticky_node	= $(this);
				var is_sticky	= sticky_node.hasClass('sticky');
				
				sticky_node.css({'margin-left': '', width: ''});
				
				if (is_sticky) {
					var sticky_width = sticky_node.outerWidth();
					
					if (sticky_width < page_width) {
						sticky_node.css('margin-left', Math.round((page_width - sticky_width) / 2));
					} else if (scroll_width > page_width) {
						sticky_node.width(page_width);
					}
				}
			});
		}
	}
};/**
 * Anchor
 * @author Jeffrey van der Veen
 */
var Anchor = function(options) {this.init(options);};

Anchor.prototype =
{
	/**
	 * Constructor
	 * @param	object options
	 * @return	void
	 */
	init: function(options)
	{
		this.options = {
			selector: 'a[href^="#"]'
		};
		
		$.extend(this.options, options);
		
		this.window				= $(window);
		this.html_body_nodes	= $('html, body');
		this.viewport_node		= $('#viewport');
		this.scroll_node		= $();
		this.link_nodes			= $();
		
		this.scroll_top = 0;
		
		this.start();
	},
	
	/**
	 * Start
	 * @return void
	 */
	start: function()
	{
		this.link_nodes = $(this.options.selector);
		
		if (this.viewport_node.css('overflow') == 'visible') {
			this.scroll_node = this.html_body_nodes;
		} else {
			this.scroll_node	= this.viewport_node;
			this.scroll_top		= this.viewport_node.offset().top;
		}
		
		this.setEvents();
	},
	
	/**
	 * Set events
	 * @return void
	 */
	setEvents: function()
	{
		var _this = this;
		
		this.link_nodes.each(function() {
			var link_node	= $(this);
			var link_href	= link_node.attr('href');
			var anchor_name	= link_href.substr(1);
			var anchor_node	= $('a[name="'+anchor_name+'"]:first');
			
			if (anchor_node.length) {
				var li_node			= link_node.parents('li:first');
				var sticky_nodes	= anchor_node.parent().prevAll('[data-sticky]');
				
				link_node.click(function(event) {
					event.preventDefault();
					
					var anchor_top = anchor_node.offset().top - _this.scroll_top;
					
					if (_this.scroll_node === _this.viewport_node) {
						anchor_top += _this.scroll_node.scrollTop();
					} else {
						anchor_top += _this.window.scrollTop();
					}
					
					if (li_node.length) {
						var active_li_nodes = li_node.siblings('li.active');
						
						active_li_nodes.removeClass('active');
						li_node.addClass('active');
					}
					
					sticky_nodes.each(function() {
						var sticky_node		= $(this);
						var sticky_height	= sticky_node.outerHeight(true);
						
						anchor_top -= sticky_height;
					});
					
					_this.scroll_node.animate({
						scrollTop: anchor_top
					},
					500);
				});
			}
		});
	}
};/**
 * Scale
 * @author Jeffrey van der Veen
 */
var Scale = function(options) {this.init(options);};

Scale.prototype =
{
	/**
	 * Constructor
	 * @param	object options
	 * @return	void
	 */
	init: function(options)
	{
		this.options = {
			selector		: '[class*="heading-"], [class*="text-"]',
			min_font_size	: 8
		};
		
		$.extend(this.options, options);
		
		this.window			= $(window);
		this.scale_nodes	= $();
		
		this.start();
	},
	
	/**
	 * Start
	 * @return void
	 */
	start: function()
	{
		this.scale_nodes = $(this.options.selector).not(':has([style*="font-size"])');
		
		this.setEvents();
		this.scale();
	},
	
	/**
	 * Set events
	 * @return void
	 */
	setEvents: function()
	{
		var _this = this;
		
		this.window.resize(function() {
			_this.scale();
		});
	},
	
	/**
	 * Scale
	 * @param	object	scale_node
	 * @param	integer	font_size
	 * @return	void
	 */
	scale: function(scale_nodes, font_size)
	{
		var _this = this;
		
		if (!scale_nodes) {
			scale_nodes = this.scale_nodes;
		}
		
		scale_nodes.each(function() {
			var scale_node		= $(this);
			var parent_node		= scale_node.parent(':visible');
			var parent_width	= parent_node.width();
			
			scale_node.css({display: 'inline-block', 'font-size': ''});
			parent_node.css('max-width', '100%');
			
			var _parent_width = parent_node.width();
			
			if (_parent_width < parent_width) {
				parent_width = _parent_width;
				
				var scale_width = scale_node.outerWidth();
				
				parent_node.css('max-width', '');
			} else {
				parent_node.css('max-width', '');
				
				var scale_width = scale_node.outerWidth();
			}
			
			scale_node.css('display', '');
			
			if (scale_width > parent_width) {
				var _font_size	= font_size ? font_size : parseInt(scale_node.css('font-size'));
				var reduction	= Math.round(_font_size / 10);
				
				if (reduction < 1) {
					reduction = 1;
				}
				
				_font_size -= reduction;
				
				if (_font_size >= _this.options.min_font_size) {
					scale_node.css({display: 'inline-block', 'font-size': _font_size});
					
					scale_width = scale_node.outerWidth();
					
					scale_node.css('display', '');
					
					if (_font_size > _this.options.min_font_size && scale_width > parent_width) {
						_this.scale(scale_node, _font_size);
					}
				}
			}
		});
	}
};/**
 * Menu
 * @author Jeffrey van der Veen
 */
var Menu = function(options) {this.init(options);};

Menu.prototype =
{
	/**
	 * Constructor
	 * @param	object options
	 * @return	void
	 */
	init: function(options)
	{
		this.options = {
			selector	: '.menu',
			mobile		: false,
			mobile_size	: 0,
			aside		: true,
			init		: true,
			bottom		: false
		};
		
		$.extend(this.options, options);
		
		this.window			= $(window);
		this.viewport_node	= $('#viewport');
		this.scroll_node	= $();
		this.page_node		= $();
		this.block_node		= $();
		this.col_node		= $();
		this.menu_node		= $();
		this.handler_node	= $();
		this.listener_node	= $();
		this.outer_node		= $();
		this.inner_node		= $();
		this.item_nodes		= $();
		
		this.viewport_top	= 0;
		this.set_mobile		= false;
		this.mobile			= false;
		this.mobile_size	= this.options.mobile_size;
		this.position		= null;
		this.inner_width	= 0;
		this.transition		= typeof document.body.style.transition !== 'undefined';
		
		this.start();
	},
	
	/**
	 * Start
	 * @return void
	 */
	start: function()
	{
		var _this		= this;
		var selectors	= this.options.selector.split(',');
		
		this.scroll_node = this.viewport_node.css('overflow') == 'visible' ? this.window : this.viewport_node;
		
		if (selectors.length > 1) {
			for (var x in selectors) {
				var options = $.extend({}, this.options);
				
				options.selector = $.trim(selectors[x]);
				
				new Menu(options);
			}
		} else {
			var menu_nodes = $(this.options.selector);
			
			menu_nodes.each(function(index) {
				if (index) {
					var options = $.extend({}, _this.options);
					
					options.selector	+= ':eq('+index+')';
					options.init	 	 = false;
					
					new Menu(options);
				} else {
					_this.menu_node		= $(this);
					_this.page_node		= _this.menu_node.parents('.page:first');
					_this.block_node	= _this.menu_node.parents('header, section, footer').first();
					_this.col_node		= _this.menu_node.parents('.col:first');
					_this.handler_node	= _this.menu_node.find('.handler:first');
					_this.listener_node	= _this.menu_node.find('.mobile-menu:first');
					_this.outer_node	= _this.listener_node.children('.outer:first');
					_this.inner_node	= _this.outer_node.children('.inner:first');
					_this.item_nodes	= _this.inner_node.find('li:has(ul)');
					
					if (_this.viewport_node.css('overflow') != 'visible') {
						_this.viewport_top = _this.viewport_node.offset().top;
					}
					
					if (!_this.options.mobile && !_this.options.mobile_size) {
						_this.inner_node.addClass('nowrap');
						
						_this.inner_width = _this.inner_node.outerWidth();
					}
					
					/*
					if (!_this.options.aside) {
						if (_this.block_node.data('sticky') !== undefined) {
							_this.listener_node.attr('data-sticky', 'sticky');
						}
					}
					*/
					
					_this.setSubHeight();
					
					if (_this.options.bottom) {
						_this.setSubPosition();
					}
					
					_this.setMobile();
					_this.setEvents();
					
					_this.menu_node.addClass('init');
				}
			});
		}
	},
	
	/**
	 * Set mobile
	 * @param	boolean force
	 * @return	void
	 */
	setMobile: function(force)
	{
		var window_width = this.window.width();
		
		if (this.page_node.hasClass('aside-'+this.position) || this.listener_node.hasClass('active')) {
			this.set_mobile = true;
			
			this.page_node.removeClass('aside-'+this.position);
			this.listener_node.removeClass('active');
		} else if (!this.set_mobile) {
			force = true;
		}
		
		if (!this.transition) {
			this.page_node.add(this.listener_node).trigger('classchange');
		}
		
		if (!this.transition || force) {
			if (!this.options.mobile && !this.options.mobile_size) {
				if (window_width > this.mobile_size) {
					if (this.mobile) {
						this.menu_node.removeClass('mobile');
						
						var outer_width = this.outer_node.width();
						
						this.menu_node.addClass('mobile');
					} else {
						var outer_width = this.outer_node.width();
					}
					
					if (this.inner_width > outer_width) {
						this.mobile_size = window_width;
					}
				}
			}
			
			if (this.options.mobile || this.mobile_size) {
				if (this.options.mobile || window_width <= this.mobile_size) {
					this.menu_node.addClass('mobile');
					
					if (!this.position) {
						this.setPosition();
					}
					
					this.mobile = true;
				} else {
					this.menu_node.removeClass('mobile');
					
					this.mobile = false;
				}
			}
		}
	},
	
	/**
	 * Set position
	 * @return void
	 */
	setPosition: function()
	{
		if (this.page_node.length && this.handler_node.length) {
			var menu_display = this.menu_node.css('display');
			
			if (this.options.aside) {
				if (this.col_node.prev('.col').length) {
					this.position = 'right';
				} else if (this.col_node.next('.col').length) {
					this.position = 'left';
				} else {
					var handler_width	= this.handler_node.width();
					var handler_left	= this.handler_node.offset().left;
					var handler_center	= handler_left + (handler_width / 2);
					var page_width		= this.page_node.width();
					var page_left		= this.page_node.offset().left;
					var page_center		= page_left + (page_width / 2);
					
					this.position = handler_center < page_center ? 'left' : 'right';
				}
			} else {
				this.position = 'center';
			}
			
			if (menu_display !== 'table-cell') {
				this.menu_node.addClass(this.position);
			}
			
			this.listener_node.addClass(this.position);
		}
	},
	
	/**
	 * Set sub height
	 * @return void
	 */
	setSubHeight: function()
	{
		this.item_nodes.each(function() {
			var item_node	= $(this);
			var list_node	= item_node.children('ul:first');
			
			list_node.addClass('measure nosize');
			
			var list_height = list_node.outerHeight();
			
			list_node.removeClass('measure nosize').css('height', list_height);
		});
	},
	
	/**
	 * Set sub position
	 * @return void
	 */
	setSubPosition: function()
	{
		if (this.item_nodes.length) {
			var col_bottom		= this.col_node.offset().top + this.col_node.outerHeight();
			var item_top		= this.item_nodes.first().offset().top;
			var list_top		= col_bottom - item_top;
			var spacer_height	= list_top - this.item_nodes.first().outerHeight();
			
			this.item_nodes.each(function() {
				var item_node	= $(this);
				var spacer_node	= item_node.children('.spacer:first');
				var list_node	= item_node.children('ul:first');
				
				if (!spacer_node.length) {
					spacer_node = $('<div>', {class: 'spacer'});
					
					list_node.before(spacer_node);
				}
				
				spacer_node.css('height', spacer_height);
				list_node.css('top', list_top);
			});
		}
	},
	
	/**
	 * Set events
	 * @return void
	 */
	setEvents: function()
	{
		var _this = this;
		
		if (!this.options.mobile && this.options.init) {
			this.window.resize(function(event, force) {
				_this.setMobile();
			});
		}
		
		if (this.options.bottom) {
			this.window.resize(function(event, force) {
				_this.setSubPosition();
			});
		}
		
		this.page_node.on({
			classchange: function() {
				if (!_this.page_node.hasClass('aside-'+_this.position)) {
					_this.listener_node.trigger('reset');
				}
			},
			click: function() {
				if (_this.page_node.hasClass('aside-'+_this.position)) {
					_this.page_node.removeClass('aside-'+_this.position);
					
					if (!_this.transition) {
						_this.page_node.trigger('classchange');
					}
				}
			}
		});
		
		if (this.transition) {
			this.page_node.add(this.listener_node).on('transitionend', function() {
				if ('target' in event && ($(event.target).is(_this.page_node) || $(event.target).is(_this.listener_node))) {
					$(this).trigger('classchange');
					
					if (_this.set_mobile) {
						_this.setMobile(true);
					}
					
					_this.set_mobile = false;
				}
			});
		}
		
		this.handler_node.click(function(event) {
			event.stopPropagation();
			event.preventDefault();
			
			if (_this.page_node.hasClass('aside-'+_this.position)) {
				_this.page_node.removeClass('aside-'+_this.position);
				_this.listener_node.removeClass('active');
				
				if (!_this.options.aside && _this.block_node.css('position') === 'fixed') {
					_this.outer_node.css({overflow: '', width: ''});
				}
				
				if (!_this.transition) {
					_this.page_node.add(_this.listener_node).trigger('classchange');
				}
			} else {
				_this.page_node.before(_this.listener_node);
				
				if (_this.options.aside) {
					var outer_width		= _this.outer_node.outerWidth();
					var inner_width		= _this.inner_node.outerWidth();
					var scrollbar_width	= outer_width - inner_width;
					
					outer_width += scrollbar_width;
					
					_this.outer_node.width(outer_width);
					
					if (_this.position == 'right') {
						var viewport_width	= _this.viewport_node.outerWidth();
						var page_width		= _this.page_node.outerWidth();
						
						scrollbar_width = viewport_width - page_width;
						
						_this.listener_node.css('right', scrollbar_width);
					}
				} else {
					var block_height	= _this.block_node.outerHeight();
					var block_top		= _this.block_node.offset().top - _this.viewport_top;
					var block_bottom	= block_height + block_top;
					
					_this.listener_node.addClass('measure nosize');
					
					var listener_height = _this.listener_node.outerHeight();
					
					_this.listener_node.removeClass('measure nosize');
					
					if (_this.block_node.css('position') === 'fixed') {
						var window_height	= _this.window.height();
						var scroll_width	= _this.scroll_node.outerWidth();
						var page_width		= _this.page_node.outerWidth();
						
						if (scroll_width > page_width) {
							_this.listener_node.width(page_width);
						}
						
						if (listener_height > (window_height - block_bottom)) {
							listener_height = window_height - block_bottom;
						}
						
						_this.listener_node.css('position', 'fixed');
					}
					
					_this.listener_node.css({height: listener_height, top: block_bottom}).height();
				}
				
				_this.handler_node.addClass('active');
				_this.page_node.addClass('aside-'+_this.position);
				_this.listener_node.addClass('active');
			}
		});
		
		this.listener_node.on({
			classchange: function() {
				if (_this.listener_node.hasClass('active')) {
					if (!_this.options.aside && _this.block_node.css('position') === 'fixed') {
						_this.outer_node.css({height: '100%', overflow: 'auto'});
						
						var outer_width		= _this.outer_node.outerWidth();
						var inner_width		= _this.inner_node.outerWidth();
						var scrollbar_width	= outer_width - inner_width;
						
						outer_width += scrollbar_width;
						
						_this.outer_node.width(outer_width);
					}
				} else {
					_this.listener_node.trigger('reset');
				}
			},
			reset: function() {
				_this.handler_node.removeClass('active').after(_this.listener_node);
				
				if (_this.options.aside) {
					_this.outer_node.css('width', '');
				} else {
					_this.listener_node.css({position: '', top: '', width: ''});
				}
			}
		});
		
		this.item_nodes.on({
			mouseenter: function() {
				var item_node		= $(this);
				var list_node		= item_node.children('ul:first');
				var list_right		= list_node.offset().left + list_node.outerWidth();
				var window_width	= _this.window.width();
				
				if (list_right > window_width) {
					var list_left = window_width - list_right;
					
					list_node.css('left', list_left);
				}
			},
			mouseleave: function() {
				var item_node	= $(this);
				var list_node	= item_node.children('ul:first');
				
				list_node.css('left', '');
			}
		});
	}
};/**
 * Cover
 * @author Jeffrey van der Veen
 */
var Cover = function(options) {this.init(options);};

Cover.prototype =
{
	/**
	 * Constructor
	 * @param	object options
	 * @return	void
	 */
	init: function(options)
	{
		this.options = {
			selector: '.cover'
		};
		
		$.extend(this.options, options);
		
		this.window		= $(window);
		this.cover_node	= $();
		this.image_node	= $();
		
		this.start();
	},
	
	/**
	 * Start
	 * @return void
	 */
	start: function()
	{
		var _this		= this;
		var selectors	= this.options.selector.split(',');
		
		if (selectors.length > 1) {
			for (var x in selectors) {
				var options = $.extend({}, this.options);
				
				options.selector = $.trim(selectors[x]);
				
				new Cover(options);
			}
		} else {
			var cover_nodes = $(this.options.selector);
			
			cover_nodes.each(function(index) {
				if (index) {
					var options = $.extend({}, _this.options);
					
					options.selector += ':eq('+index+')';
					
					new Cover(options);
				} else {
					_this.cover_node	= $(this);
					_this.image_node	= _this.cover_node.children('img:first');
					
					_this.scaleImage();
					_this.setEvents();
				}
			});
		}
	},
	
	/**
	 * Scale image
	 * @return void
	 */
	scaleImage: function()
	{
		this.image_node.css({height: '', width: ''});
		
		var _this			= this;
		var image_height	= this.image_node.height();
		
		if (image_height) {
			var cover_height = this.cover_node.outerHeight();
			
			if (image_height < cover_height) {
				this.image_node.css({height: '101%', width: 'auto'});
			}
		} else {
			this.image_node.on('load', function() {
				_this.scaleImage();
			});
		}
	},
	
	/**
	 * Set events
	 * @return void
	 */
	setEvents: function()
	{
		var _this = this;
		
		this.window.resize(function() {
			_this.scaleImage();
		});
	}
};/**
 * Popup
 * @author Jeffrey van der Veen
 */
var Popup = function(options) {this.init(options);};

Popup.prototype =
{
	/**
	 * Constructor
	 * @param	object options
	 * @return	void
	 */
	init: function(options)
	{
		this.options = {
			selector: 'a[href][target="popup"]'
		};
		
		$.extend(this.options, options);
		
		this.window			= $(window);
		this.body_node		= $('body');
		this.handler_nodes	= $();
		this.handler_node	= $();
		this.popup_node		= $();
		this.viewport_node	= $();
		this.coltrols_node	= $();
		this.close_node		= $();
		this.previous_node	= $();
		this.next_node		= $();
		this.counter_node	= $();
		
		this.handler_index	= 0;
		this.handler_count	= 0;
		
		this.start();
	},
	
	/**
	 * Start
	 * @return void
	 */
	start: function()
	{
		this.handler_nodes	= $(this.options.selector);
		this.handler_count	= this.handler_nodes.length;
		
		if (this.handler_count) {
			this.popup_node		= $('<div>', {class: 'popup', style: 'display: none;'});
			this.viewport_node	= $('<div>', {class: 'viewport'});
			this.controls_node	= $('<div>', {class: 'controls'});
			this.close_node		= $('<a>', {href: '#', class: 'close'});
			
			this.controls_node.append(this.close_node);
			
			if (this.handler_count > 1) {
				this.previous_node	= $('<a>', {href: '#', class: 'previous'});
				this.next_node		= $('<a>', {href: '#', class: 'next'});
				this.counter_node	= $('<div>', {class: 'counter'});
				
				this.controls_node.append(this.previous_node, this.next_node, this.counter_node);
			}
			
			this.popup_node.append(this.viewport_node, this.controls_node);
			this.body_node.append(this.popup_node);
			
			this.setEvents();
			
			this.handler_nodes.addClass('loaded');
		}
	},
	
	/**
	 * Set events
	 * @return void
	 */
	setEvents: function()
	{
		var _this = this;
		
		this.window.keyup(function(event) {
			var is_visible = _this.popup_node.is(':visible');
			
			if (is_visible) {
				var key_code = event.keyCode;
				
				switch (key_code) {
					case 27:
						_this.close_node.trigger('click');
						break;
					case 37:
						_this.previous_node.trigger('click');
						break;
					case 39:
						_this.next_node.trigger('click');
				}
			}
		});
		
		this.popup_node.click(function() {
			_this.popup_node.hide();
			_this.viewport_node.empty();
		});
		
		this.close_node.click(function(event) {
			event.preventDefault();
		});
		
		this.previous_node.click(function(event) {
			event.preventDefault();
			event.stopPropagation();
			
			var previous_handler_index	= _this.handler_index ? _this.handler_index - 1 : _this.handler_count - 1;
			var previous_handler_node	= _this.handler_nodes.filter(':eq('+previous_handler_index+')');
			
			previous_handler_node.trigger('click');
		});
		
		this.next_node.click(function(event) {
			event.preventDefault();
			event.stopPropagation();
			
			var next_handler_index	= _this.handler_index < (_this.handler_count - 1) ? _this.handler_index + 1 : 0;
			var next_handler_node	= _this.handler_nodes.filter(':eq('+next_handler_index+')');
			
			next_handler_node.trigger('click');
		});
		
		this.handler_nodes.click(function(event) {
			event.preventDefault();
			
			_this.handler_node	= $(this);
			_this.handler_index	= _this.handler_nodes.index(_this.handler_node);
			
			var href		= _this.handler_node.attr('href');
			var counter		= _this.handler_index + 1;
			var is_visible	= _this.popup_node.is(':visible');
			var matches		= null;
			
			_this.counter_node.text(counter+'/'+_this.handler_count);
			
			if (href.match(/\.(bmp|gif|jpeg|jpg|png|svg|tif|tiff)$/i)) {
				var content_node = $('<img>', {src: href});
			} else if (href.match(/\.mp4$/i)) {
				var content_node = $('<video>', {src: href, autoplay: true, controls: true});
			} else if (matches = href.match(/^(?:http(?:s)?:)?\/\/((www\.)?youtube\.com\/embed|player\.vimeo\.com)\//i)) {
				var content_node	= $('<div>', {class: 'iframe'});
				var inner_node		= $('<div>');
				var iframe_node		= $('<iframe>', {src: href, allowfullscreen: true});
				
				inner_node.append(iframe_node);
				content_node.append(inner_node);
			} else {
				var content_node = $('<div>', {class: 'content'});
			}
			
			content_node.click(function(event) {
				event.stopPropagation();
			});
			
			if (is_visible) {
				_this.viewport_node.html(content_node);
			} else {
				_this.viewport_node.append(content_node);
				_this.popup_node.show();
			}
		});
	}
};