http://sjperse.org/jquery/royalslider/jquery.royalslider.min.js

1(function(jQuery) {
2/*
3 * RoyalSlider
4 *
5 * @version 9.5.7:
6 *
7 * Copyright, Dmitry Semenov
8 * Modified by LMSOFT see modification in _updateBlocksContent/_refreshNumPreloadImages function
9 *
10 */
11(function($) {
12
13	"use strict";
14
15	if(!$.rsModules) {
16		$.rsModules = {uid:0};
17	}
18
19	function RoyalSlider(element, options) {
20		var i,
21			self = this,
22			navigator = window.navigator,
23			ua = navigator.userAgent.toLowerCase();
24
25		self.uid = $.rsModules.uid++;
26		self.ns = '.rs' + self.uid; // unique namespace for events
27
28		// feature detection, some ideas taken from Modernizr
29		var tempStyle = document.createElement('div').style,
30			vendors = ['webkit','Moz','ms','O'],
31			vendor = '',
32			lastTime = 0,
33			tempV;
34
35		for (i = 0; i < vendors.length; i++ ) {
36			tempV = vendors[i];
37			if (!vendor && (tempV + 'Transform') in tempStyle ) {
38				vendor = tempV;
39			}
40			tempV = tempV.toLowerCase();
41			
42			if(!window.requestAnimationFrame) {
43				window.requestAnimationFrame = window[tempV+'RequestAnimationFrame'];
44				window.cancelAnimationFrame = window[tempV+'CancelAnimationFrame'] || window[tempV+'CancelRequestAnimationFrame'];
45			}
46		}
47
48		// requestAnimationFrame polyfill by Erik Möller
49		// fixes from Paul Irish and Tino Zijdel
50		if (!window.requestAnimationFrame) {
51			window.requestAnimationFrame = function(callback, element) {
52				var currTime = new Date().getTime(),
53					timeToCall = Math.max(0, 16 - (currTime - lastTime)),
54					id = window.setTimeout(function() { callback(currTime + timeToCall); }, timeToCall);
55					lastTime = currTime + timeToCall;
56				return id;
57			};
58		}
59
60		if (!window.cancelAnimationFrame) {
61			window.cancelAnimationFrame = function(id) { clearTimeout(id); };
62		}
63			
64
65		self.isIPAD = ua.match(/(ipad)/);
66		self.isIOS = self.isIPAD || ua.match(/(iphone|ipod)/);
67
68
69		// browser UA sniffing, sadly still required
70		var uaMatch = function( ua ) {
71			var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
72				/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
73				/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
74				/(msie) ([\w.]+)/.exec( ua ) ||
75				ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
76				[];
77
78			return {
79				browser: match[ 1 ] || "",
80				version: match[ 2 ] || "0"
81			};
82		};
83		var matched = uaMatch( ua );
84		var br = {};
85		if ( matched.browser ) {
86			br[ matched.browser ] = true;
87			br.version = matched.version;
88		}
89
90		if(br.chrome) { 
91			br.webkit = true;
92		}
93
94		self._browser = br;
95		self.isAndroid = ua.indexOf("android") > -1;
96
97
98
99		self.slider = $(element); // DOM reference
100		self.ev = $(self); // event object
101		self._doc = $(document);
102		self.st = $.extend({}, $.fn.royalSlider.defaults, options); 
103		self._currAnimSpeed = self.st.transitionSpeed;
104		self._minPosOffset = 0;
105		if(self.st.allowCSS3) {
106			if((!br.webkit || self.st.allowCSS3OnWebkit) ) {
107				var bT = vendor + (vendor ? 'T' : 't' );
108				self._useCSS3Transitions = ( (bT + 'ransform') in tempStyle ) && ( (bT + 'ransition') in tempStyle );
109				if(self._useCSS3Transitions) {
110					self._use3dTransform = (vendor + (vendor ? 'P' : 'p'  ) + 'erspective') in tempStyle;
111				}
112			}
113		}
114		
115		vendor = vendor.toLowerCase();
116		self._vendorPref = '-'+vendor+'-';
117		
118		self._slidesHorizontal = (self.st.slidesOrientation === 'vertical') ? false : true;
119		self._reorderProp = self._slidesHorizontal ? 'left' : 'top';
120		self._sizeProp = self._slidesHorizontal ? 'width' : 'height';
121		self._prevNavItemId = -1;
122		self._isMove = (self.st.transitionType === 'fade') ? false : true;
123		if(!self._isMove) {
124			self.st.sliderDrag = false;
125			self._fadeZIndex = 10;
126		}
127		self._opacityCSS = 'z-index:0; display:none; opacity:0;';
128
129		self._newSlideId = 0;
130		self._sPosition = 0;
131		self._nextSlidePos = 0;
132
133		// init modules
134		$.each($.rsModules, function (helper, opts) {
135			if(helper !== 'uid')
136				opts.call(self);
137		});
138
139		// parse all slides
140		self.slides = [];
141		self._idCount = 0;
142		var returnVal;
143		var ts = self.st.slides ? $(self.st.slides) : self.slider.children().detach();
144		
145		ts.each(function() {
146			self._parseNode(this, true);
147		});
148
149		if(self.st.randomizeSlides) {
150			self.slides.sort(function() { return 0.5 - Math.random(); });
151		}
152		self.numSlides = self.slides.length;
153		self._refreshNumPreloadImages();
154
155		if(!self.st.startSlideId) {
156			self.st.startSlideId = 0;
157		} else if(self.st.startSlideId > self.numSlides - 1) {
158			self.st.startSlideId = self.numSlides - 1;
159		}
160
161		self._newSlideId = self.staticSlideId = self.currSlideId = self._realId =  self.st.startSlideId;
162		self.currSlide = self.slides[self.currSlideId];
163
164		self._accelerationPos = 0;
165		self.pointerMultitouch = false;
166		self.slider.addClass( (self._slidesHorizontal ? 'rsHor' : 'rsVer') + (self._isMove ? '' : ' rsFade') );
167
168		var sliderHTML = '<div class="rsOverflow"><div class="rsContainer">';
169		self.slidesSpacing = self.st.slidesSpacing;
170		self._slideSize = ( self._slidesHorizontal ? self.slider.width() : self.slider.height() ) + self.st.slidesSpacing;
171
172		self._preload = Boolean(self._numPreloadImages > 0);
173		
174		if(self.numSlides <= 1) {
175			self._loop = false;
176		}
177		var loopHelpers = (self._loop && self._isMove) ? ( self.numSlides === 2 ? 1 : 2) : 0;
178		self._loopHelpers = loopHelpers;
179
180		self._maxImages = self.numSlides < 6 ? self.numSlides : 6;
181		self._currBlockIndex = 0;
182
183
184		self._idOffset = 0;
185		self.slidesJQ = [];
186		
187		for(i =0; i < self.numSlides; i++) {
188			self.slidesJQ.push( $(createItemHTML(i)) );
189		}
190		self._sliderOverflow = sliderHTML = $(sliderHTML + '</div></div>');
191
192
193		var addCursors = function() {
194			if(self.st.sliderDrag) {
195				self._hasDrag = true;
196				if (br.msie || br.opera) {
197					self._grabCursor = self._grabbingCursor = "move";
198				} else if(br.mozilla) {
199					self._grabCursor = "-moz-grab";
200					self._grabbingCursor = "-moz-grabbing";
201				} else if(br.webkit && (navigator.platform.indexOf("Mac")!=-1)) {
202					self._grabCursor = "-webkit-grab";
203					self._grabbingCursor = "-webkit-grabbing";
204				}

205				self._setGrabCursor();
206			}
207		};
208		var rsNS = self.ns;
209		var addEventNames = function(pref, down, move, up, cancel) {
210			self._downEvent = pref + down + rsNS;
211			self._moveEvent = pref + move + rsNS;
212			self._upEvent = pref + up + rsNS;
213			if(cancel)
214				self._cancelEvent = pref + cancel + rsNS;
215		};
216
217
218		// Pointer events support
219		var nPointerEnabled = navigator.pointerEnabled;
220		self.pointerEnabled = nPointerEnabled || navigator.msPointerEnabled;
221
222		if(self.pointerEnabled) {
223			self.hasTouch = false;
224			self._lastItemFriction = 0.2;
225			// Hardware supports multitouch
226			self.pointerMultitouch = Boolean(navigator[ (nPointerEnabled ? 'm' : 'msM') + 'axTouchPoints' ] > 1);
227			if(nPointerEnabled) {
228				// >= IE11 & other devices that support pointer events
229				addEventNames('pointer', 'down', 'move', 'up', 'cancel');
230			} else {
231				// IE10
232				addEventNames('MSPointer', 'Down', 'Move', 'Up', 'Cancel');
233			}
234		} else {
235
236			// IOS can't handle both touch and mouse events at once
237			if(!self.isIOS) {
238				addEventNames('mouse', 'down', 'move', 'up');
239			} else {
240				self._downEvent = self._moveEvent = self._upEvent = self._cancelEvent = '';
241			}
242
243			if('ontouchstart' in window || 'createTouch' in document) {
244				self.hasTouch = true;
245				self._downEvent += ' touchstart' + rsNS;
246				self._moveEvent += ' touchmove' + rsNS;
247				self._upEvent += ' touchend' + rsNS;
248				self._cancelEvent += ' touchcancel' + rsNS;
249				self._lastItemFriction = 0.5;
250				if(self.st.sliderTouch) {
251					self._hasDrag = true;
252				}
253			} else {
254				self.hasTouch = false;
255				self._lastItemFriction = 0.2;
256			}
257		}
258		addCursors();
259	
260		self.slider.html(sliderHTML);
261
262		
263		self._controlsContainer = self.st.controlsInside ? self._sliderOverflow : self.slider;
264		
265		self._slidesContainer = self._sliderOverflow.children('.rsContainer');
266		if(self.pointerEnabled) {
267			self._slidesContainer.css( (nPointerEnabled ? '' : '-ms-') + 'touch-action', self._slidesHorizontal ? 'pan-y' : 'pan-x');
268		}
269		self._preloader = $('<div class="rsPreloader"></div>');
270		var slides = self._slidesContainer.children('.rsSlide');
271
272		self._currHolder = self.slidesJQ[self.currSlideId];
273		self._selectedSlideHolder = 0;
274
275		function createItemHTML(i, className) {
276			return '<div style="'+ (self._isMove ? '' : (i !== self.currSlideId  ? self._opacityCSS : 'z-index:0;') ) +'" class="rsSlide '+ (className || '')+'"></div>';
277		}
278		
279		if(self._useCSS3Transitions) {
280
281			// some constants for CSS3
282			self._TP = 'transition-property';
283			self._TD = 'transition-duration';
284			self._TTF = 'transition-timing-function';
285
286			self._yProp = self._xProp = self._vendorPref +'transform';
287
288			if(self._use3dTransform) {
289				if(br.webkit && !br.chrome) {
290					self.slider.addClass('rsWebkit3d');
291				}
292
293				self._tPref1 = 'translate3d(';
294				self._tPref2 = 'px, ';
295				self._tPref3 = 'px, 0px)';
296			} else {
297				self._tPref1 = 'translate(';
298				self._tPref2 = 'px, ';
299				self._tPref3 = 'px)';
300			}
301			if(!self._isMove) {
302				var animObj = {};
303				animObj[(self._vendorPref + self._TP)] = 'opacity';
304				animObj[(self._vendorPref + self._TD)] = self.st.transitionSpeed + 'ms';
305				animObj[(self._vendorPref + self._TTF)] = self.st.css3easeInOut;
306				slides.css(animObj);
307			} else {
308				self._slidesContainer[(self._vendorPref + self._TP)] = (self._vendorPref + 'transform');
309			}
310			
311
312		} else {
313			self._xProp = 'left';
314			self._yProp = 'top';
315		}
316
317		
318
319		// window resize
320		var resizeTimer;
321		$(window).on('resize'+self.ns, function() {	
322			if(resizeTimer) {
323				clearTimeout(resizeTimer);			
324			}
325			resizeTimer = setTimeout(function() { self.updateSliderSize(); }, 50);			
326		});	
327		self.ev.trigger('rsAfterPropsSetup'); // navigation (bullets, thumbs...) are created here
328
329		self.updateSliderSize();
330
331
332		// keyboard nav
333		if(self.st.keyboardNavEnabled) {
334			self._bindKeyboardNav();
335		}
336
337		if(self.st.arrowsNavHideOnTouch && (self.hasTouch || self.pointerMultitouch) ) {
338			self.st.arrowsNav = false;
339		}
340
341		//Direction navigation (arrows)
342		if(self.st.arrowsNav) {
343			var rArr = 'rsArrow',
344				container = self._controlsContainer;
345			$('<div class="'+rArr+' '+rArr+'Left"><div class="'+rArr+'Icn"></div></div><div class="'+rArr+' '+rArr+'Right"><div class="'+rArr+'Icn"></div></div>').appendTo(container);
346
347			self._arrowLeft = container.children('.'+rArr+'Left').click(function(e) {
348				e.preventDefault();
349				self.prev();
350			});
351			self._arrowRight = container.children('.'+rArr+'Right').click(function(e) {
352				e.preventDefault();
353				self.next();
354			});
355
356			if(self.st.arrowsNavAutoHide && !self.hasTouch) {
357				self._arrowLeft.addClass('rsHidden');
358				self._arrowRight.addClass('rsHidden');
359
360				var hoverEl = container;
361				hoverEl.one("mousemove.arrowshover",function() {
362					self._arrowLeft.removeClass('rsHidden');
363					self._arrowRight.removeClass('rsHidden');			
364				});
365
366
367				hoverEl.hover(
368					function() {
369						if(!self._arrowsAutoHideLocked) {
370							self._arrowLeft.removeClass('rsHidden');
371							self._arrowRight.removeClass('rsHidden');
372						}
373					},
374					function() {
375						if(!self._arrowsAutoHideLocked) {
376							self._arrowLeft.addClass('rsHidden');
377							self._arrowRight.addClass('rsHidden');
378						}
379					}
380				);	
381			}	
382			self.ev.on('rsOnUpdateNav', function() {
383				self._updateArrowsNav();
384			});
385			self._updateArrowsNav();
386		}
387
388			
389		
390		if( (self.hasTouch && self.st.sliderTouch) || (!self.hasTouch && self.st.sliderDrag) ) {
391			self._slidesContainer.on(self._downEvent, function(e) { self._onDragStart(e); });	
392		} else {
393			self.dragSuccess = false;
394		}

395		var videoClasses = ['rsPlayBtnIcon', 'rsPlayBtn', 'rsCloseVideoBtn', 'rsCloseVideoIcn'];
396		self._slidesContainer.click(function(e) {
397			if(!self.dragSuccess) {
398				var t = $(e.target);
399				var tClass = t.attr('class');
400				if( $.inArray(tClass, videoClasses) !== -1) {
401					if( self.toggleVideo() ) {
402						return false;
403					}
404				}
405				if(self.st.navigateByClick && !self._blockActions) {
406					if($(e.target).closest('.rsNoDrag', self._currHolder).length) {
407						return true;
408					}
409					self._mouseNext(e);
410				} 
411				self.ev.trigger('rsSlideClick', e);
412			} 
413		}).on('click.rs', 'a', function(e) {	
414			if(self.dragSuccess) {						
415				return false;
416			} else {
417				self._blockActions = true;
418				//e.stopPropagation();
419				//e.stopImmediatePropagation();
420				setTimeout(function() {
421					self._blockActions = false;
422				}, 3);
423			}
424		});
425		self.ev.trigger('rsAfterInit');
426	} /* RoyalSlider Constructor End */
427
428	/**
429	 *
430	 * RoyalSlider Core Prototype
431	 * 
432	 */
433	RoyalSlider.prototype = {
434		constructor: RoyalSlider,
435		_mouseNext: function(e) {
436			var self = this,
437				relativePos = e[self._slidesHorizontal ? 'pageX' : 'pageY'] - self._sliderOffset;
438
439			if(relativePos >= self._nextSlidePos) {
440				self.next();
441			} else if(relativePos < 0) {
442				self.prev();
443			}
444		},
445		/**
446		 * This function have been modified by LMSOFT/Abder to force royalslider to add all slides all the time
447		*/
448		_refreshNumPreloadImages: function() {
449			var self = this,
450				n;
451			n = self.st.numImagesToPreload;
452			self._loop = self.st.loop;
453
454			if(self._loop) {
455				if(self.numSlides === 2) {
456					self._loop = false;
457					self.st.loopRewind = true;
458				} else if(self.numSlides < 2) {
459					self.st.loopRewind = self._loop = false;
460				}
461				
462			}
463			if(self._loop && n > 0) {
464				if(self.numSlides <= 4) {
465					n = 1;
466				} else {
467					//if(self.st.numImagesToPreload > (self.numSlides - 1) / 2 ) {
468						n = Math.floor( (self.numSlides - 1) / 2 );
469					//}
470				} 
471			}
472			self._numPreloadImages = n;
473		},
474		_parseNode: function(content, pushToSlides) {
475			var self = this,
476				hasImg,
477				isRoot,
478				hasCover,
479				obj = {},
480				tempEl,
481				first = true;
482			content = $(content);
483			self._currContent = content;
484			self.ev.trigger('rsBeforeParseNode', [content, obj]);
485			if(obj.stopParsing) {
486				return;
487			}
488			content = self._currContent;
489			obj.id = self._idCount;
490			obj.contentAdded = false;
491			self._idCount++;
492			obj.images = [];
493			obj.isBig = false;
494
495			if(!obj.hasCover) {
496				if(content.hasClass('rsImg')) {
497					tempEl = content;
498					hasImg = true;
499				} else {
500					tempEl = content.find('.rsImg');
501					if(tempEl.length) {
502						hasImg = true;
503					}
504				}
505
506				if(hasImg) {
507					obj.bigImage = tempEl.eq(0).attr('data-rsBigImg');
508					tempEl.each(function() {
509						var item = $(this);
510						if(item.is('a')) {
511							parseEl(item, 'href');
512						} else if(item.is('img')) {
513							parseEl(item, 'src');
514						} else {
515							parseEl(item);
516						}
517					});
518				} else if(content.is('img')) {
519					content.addClass('rsImg rsMainSlideImage');
520					parseEl(content, 'src');
521				}
522			}
523			tempEl = content.find('.rsCaption');
524			if(tempEl.length) {
525				obj.caption = tempEl.remove();
526			}
527			obj.content = content;
528
529			self.ev.trigger('rsAfterParseNode', [content, obj]);
530			function parseEl(el, s) {
531				if(s) {
532					obj.images.push( el.attr(s) );
533				} else {
534					obj.images.push( el.text() );
535				}
536				if(first) {
537					first = false;
538					obj.caption = (s === 'src') ? el.attr('alt') : el.contents();
539					obj.image = obj.images[0];
540					obj.videoURL = el.attr('data-rsVideo');
541					
542					
543					var wAtt = el.attr('data-rsw'),
544						hAtt = el.attr('data-rsh');
545					if (typeof wAtt !== 'undefined' && wAtt !== false && typeof hAtt !== 'undefined' && hAtt !== false ) {
546						obj.iW = parseInt(wAtt, 10);
547						obj.iH = parseInt(hAtt, 10);
548					} else if(self.st.imgWidth && self.st.imgHeight ) {
549						obj.iW = self.st.imgWidth;
550						obj.iH = self.st.imgHeight;
551					}
552				}
553			}
554			if(pushToSlides) {
555				self.slides.push(obj);
556			}
557			if(obj.images.length === 0) {
558				obj.isLoaded = true;
559				obj.isRendered = false;
560				obj.isLoading = false;
561				obj.images = null;
562			}
563			return obj;

564		},
565		_bindKeyboardNav: function() {
566			var self = this,
567				interval,
568				keyCode,
569				onKeyboardAction = function (keyCode) {
570					if(keyCode === 37) {
571						self.prev();
572					} else if (keyCode === 39) {
573						self.next();
574					}
575				};
576
577			self._doc.on('keydown' + self.ns, function(e) {
578				if(!self.st.keyboardNavEnabled) {
579					return true;
580				}
581				if(!self._isDragging) {
582					keyCode = e.keyCode;
583					if(keyCode === 37 || keyCode === 39) {
584
585						if(!interval) {
586							if(document.activeElement && (/(INPUT|SELECT|TEXTAREA)/i).test(document.activeElement.tagName)) {
587								return true;
588							}
589							if(self.isFullscreen) {
590								e.preventDefault();
591							}
592							
593							onKeyboardAction(keyCode);
594							interval = setInterval(function() {
595								onKeyboardAction(keyCode);
596							}, 700);
597						}
598					}
599				}
600			}).on('keyup' + self.ns, function(e) {
601				if(interval) {
602					clearInterval(interval); 
603					interval = null;
604				}
605			});
606
607			
608			
609		},
610
611
612
613
614		goTo: function(id, notUserAction) {
615			var self = this;
616			if(id !== self.currSlideId) {
617				self._moveTo(id,self.st.transitionSpeed, true, !notUserAction);
618			}
619		},
620		destroy: function(remove) {
621			var self = this;
622			self.ev.trigger('rsBeforeDestroy');
623			self._doc.off('keydown' +self.ns+ ' keyup' + self.ns + ' ' + self._moveEvent +' '+ self._upEvent );
624			self._slidesContainer.off(self._downEvent + ' click');	
625			self.slider.data('royalSlider', null);
626			$.removeData(self.slider, 'royalSlider');
627			$(window).off('resize' + self.ns);
628			if(self.loadingTimeout) {
629			  clearTimeout(self.loadingTimeout);
630			}
631			if(remove) {
632				self.slider.remove();
633			}
634			self.slides = null;
635			self.slider = null;
636			self.ev = null;
637		},
638		/**
639		 * This function have been modified by LMSOFT/Abder to force royalslider to add all slides all the time
640		*/
641		_updateBlocksContent: function(beforeTransition, getId) {
642			var self = this,
643				item,
644				i,
645				n,
646				pref,
647				group,
648				groupId,
649				slideCode,
650				loop = self._loop,
651				numSlides = self.numSlides;
652			if(!isNaN(getId) ) {
653				return getCorrectLoopedId(getId);
654			}
655
656
657			var id = self.currSlideId;
658			var groupOffset;
659			
660			var itemsOnSide = beforeTransition ? (Math.abs(self._prevSlideId - self.currSlideId) >= self.numSlides - 1 ? 0 : 1) : self._numPreloadImages;
661			// add the same to the leftSide
662			var itemsOnleftSide = itemsOnSide;
663			// si on a un nombre pair de slides on ajoute l'element manquant sur la doite
664			var itemsOnRightSide = (self.numSlides % 2) == 0 ? itemsOnSide + 1 : itemsOnSide;
665			
666			var itemsToCheck = Math.min(2, itemsOnSide); 
667			
668			var updateAfter = false;
669			var updateBefore = false;
670			var tempId;
671			
672			for(i = id; i < id + 1 + itemsToCheck; i++) {
673				tempId = getCorrectLoopedId(i);
674				item = self.slides[tempId];
675				if(item && (!item.isAdded || !item.positionSet) ) {
676					updateAfter = true;
677					break;
678				}
679			}
680			for(i = id - 1; i > id - 1 - itemsToCheck; i--) {
681				tempId = getCorrectLoopedId(i);
682				item = self.slides[tempId];
683				if(item && (!item.isAdded || !item.positionSet) ) {
684					updateBefore = true;
685					break;
686				}
687			}
688			if(updateAfter) {
689				for(i = id; i < id + itemsOnRightSide + 1; i++) {
690					tempId = getCorrectLoopedId(i);
691					groupOffset = Math.floor( (self._realId - (id - i)) / self.numSlides) * self.numSlides;
692					item = self.slides[tempId];
693					if(item) {
694						updateItem(item, tempId);	
695					}
696				}
697			}
698			if(updateBefore) {
699				for(i = id - 1; i > id - 1 - itemsOnleftSide; i--) {
700					tempId = getCorrectLoopedId(i);
701					groupOffset = Math.floor( (self._realId - (id - i) ) / numSlides) * numSlides;
702					item = self.slides[tempId];
703					if(item) {
704						updateItem(item, tempId);
705					}
706				}
707			}
708			if(!beforeTransition) {
709				var start = id;
710				var distance = itemsOnSide;
711				var min = getCorrectLoopedId(id - itemsOnleftSide);
712				var max = getCorrectLoopedId(id + itemsOnRightSide);
713				
714				var nmin = min > max ? 0 : min;
715				
716				for (i = 0; i < numSlides; i++) { 
717					if(min > max) {
718						if(i > min - 1) {
719							continue;
720						}
721					}
722					if(i < nmin || i > max) {
723						item = self.slides[i];

724						if(item && !item.isAdded) {
725							updateItem(item, i);
726						}
727						if(item && item.holder) {
728							item.holder.detach();
729							item.isAdded = false;
730						}     
731					}                               
732				}   
733			}
734
735			
736			
737				
738				
739			function updateItem(item , i, slideCode) {
740
741				if(!item.isAdded) {
742					if(!slideCode)
743						slideCode = self.slidesJQ[i];
744
745					if(!item.holder) {
746						slideCode = self.slidesJQ[i] = $(slideCode);
747						item.holder = slideCode;
748					} else {
749						slideCode = item.holder;
750					}
751
752					item.appendOnLoaded = false;
753
754					
755					updatePos(i, item, slideCode);
756					addContent(i, item);
757					self._addBlockToContainer(item, slideCode, beforeTransition);
758					item.isAdded = true;
759				} else {
760					addContent(i, item);
761					updatePos(i, item);
762				}
763			}
764			function addContent(i, item) {
765				if(!item.contentAdded) {
766					self.setItemHtml(item, beforeTransition);
767					if(!beforeTransition) {
768						item.contentAdded = true;
769					}
770					
771				}
772			}
773			function updatePos(i, item, slideCode) {
774				if(self._isMove) {
775					if(!slideCode) {
776						slideCode = self.slidesJQ[i];
777					}
778
779					slideCode.css(self._reorderProp, (i + self._idOffset + groupOffset) * self._slideSize);
780				}
781			}
782			function getCorrectLoopedId(index) {
783				var changed = false;
784				if(loop) {
785					if(index > numSlides - 1) {
786						return getCorrectLoopedId(index - numSlides);
787					} else  if(index < 0) {
788						return getCorrectLoopedId(numSlides + index);
789					}
790				}
791				return index;
792			}
793			
794		},
795
796		/**
797		 * Sets or loads HTML for specified slide
798		 * @param {Object} currSlideObject  holds data about curr slide (read about rsAfterParseNode for more info)
799		 * @param {Boolean} beforeTransition determines if setItemHTML method is called before or after transition
800		 */
801		setItemHtml: function(currSlideObject, beforeTransition) {
802			var self = this;
803
804			var parseDataAndLoad = function() {
805				if(!currSlideObject.images) {
806					currSlideObject.isRendered = true;
807					currSlideObject.isLoaded = true;
808					currSlideObject.isLoading = false;
809					appendContent(true);
810					return;
811				}
812				if(currSlideObject.isLoading) {
813					return;
814				}
815				
816				var el,
817					isRoot;
818				if(currSlideObject.content.hasClass('rsImg') ) {
819					el = currSlideObject.content;
820					isRoot = true;
821				} else {
822					el = currSlideObject.content.find('.rsImg:not(img)');
823				}
824				if(el && !el.is('img')) {
825					el.each(function() {
826						var item = $(this),
827							newEl = '<img class="rsImg" src="'+ ( item.is('a') ? item.attr('href') : item.text() ) +'" />';
828
829						if(!isRoot) {
830							item.replaceWith( newEl );
831						} else {
832							currSlideObject.content = $(newEl);
833						}
834					});
835				}
836				
837				el = isRoot ? currSlideObject.content : currSlideObject.content.find('img.rsImg');
838				setPreloader();
839				
840				el.eq(0).addClass('rsMainSlideImage');
841				if(currSlideObject.iW && currSlideObject.iH) {
842					if(!currSlideObject.isLoaded) {
843						self._resizeImage( currSlideObject );
844					}
845					appendContent();
846				}
847
848				currSlideObject.isLoading = true;
849				var newEl;
850
851				var eNames = 'load.rs error.rs';
852				if(currSlideObject.isBig) {
853					$('<img />').on(eNames, function(e){
854						$(this).off(eNames);
855						onLoad( [this], true );
856					}).attr('src', currSlideObject.image);
857				} else {
858					currSlideObject.loaded = [];
859					currSlideObject.numStartedLoad = 0;
860					var onLoaded = function(e) {
861						$(this).off(eNames);
862						currSlideObject.loaded.push( this );
863						if(currSlideObject.loaded.length === currSlideObject.numStartedLoad) {
864							onLoad( currSlideObject.loaded, false );
865						}
866					};
867					for(var i = 0; i < currSlideObject.images.length; i++) {
868						var image = $('<img />');
869						currSlideObject.numStartedLoad++;
870						image.on('load.rs error.rs', onLoaded).attr('src', currSlideObject.images[i]);
871					}
872				}
873			};
874
875			var onLoad = function($images, isBig) {
876				if($images.length) {
877					var img = $images[0],
878					src = img.src;
879
880					if(isBig !== currSlideObject.isBig) {
881						var c = currSlideObject.holder.children();

882						if(c && c.length > 1) {
883							removePreloader();
884						}
885						return;
886					}
887
888					if(currSlideObject.iW && currSlideObject.iH) {
889						imageLoadingComplete();
890						return;
891					}
892					currSlideObject.iW = img.width;
893					currSlideObject.iH = img.height;
894					if(currSlideObject.iW && currSlideObject.iH) {
895						imageLoadingComplete();
896						return;
897					} else {
898						// if no size, try again
899						var loader = new Image();
900						loader.onload = function() {
901							if(loader.width) {
902								currSlideObject.iW = loader.width;
903								currSlideObject.iH = loader.height;
904								imageLoadingComplete();
905							} else {
906								setTimeout(function() {
907									if(loader.width) {
908										currSlideObject.iW = loader.width;
909										currSlideObject.iH = loader.height;
910									}
911
912									// failed to get size on last tier, just output image
913									imageLoadingComplete();
914								}, 1000);
915							}
916						};
917						loader.src = img.src;
918					}
919				} else {
920					imageLoadingComplete();
921				}
922			};
923
924			var imageLoadingComplete = function () {
925				currSlideObject.isLoaded = true;
926				currSlideObject.isLoading = false;
927
928				appendContent();
929				removePreloader();
930				triggerLoaded();
931			};
932
933			var waitForTransition = function () {
934				if(!self._isMove && currSlideObject.images && currSlideObject.iW && currSlideObject.iH) {
935					parseDataAndLoad();
936					return;
937				}
938				currSlideObject.holder.isWaiting = true;
939				setPreloader();
940				currSlideObject.holder.slideId = -99;
941			};
942			
943			var appendContent = function() {
944				if(!currSlideObject.isAppended && self.ev) {
945
946					var visibleNearby = self.st.visibleNearby,
947					bId = currSlideObject.id - self._newSlideId;
948					if(!beforeTransition && !currSlideObject.appendOnLoaded && self.st.fadeinLoadedSlide  && ( bId === 0 || ( (visibleNearby || self._isAnimating || self._isDragging) && (bId === -1 || bId === 1) ) ) ) {
949						var css = {
950							visibility: 'visible', 
951							opacity: 0
952						};
953						css[self._vendorPref + 'transition'] = 'opacity 400ms ease-in-out';
954						currSlideObject.content.css(css);
955
956						setTimeout(function() {
957							currSlideObject.content.css('opacity', 1);
958						}, 16);
959					}
960
961					if(currSlideObject.holder.find('.rsPreloader').length) {
962						currSlideObject.holder.append( currSlideObject.content );
963					} else {
964						currSlideObject.holder.html( currSlideObject.content );
965					}
966					
967
968					currSlideObject.isAppended = true;
969					if(currSlideObject.isLoaded) {
970						self._resizeImage(currSlideObject);
971						triggerLoaded();
972					}
973					if(!currSlideObject.sizeReady) {
974						currSlideObject.sizeReady = true;
975						setTimeout(function() {
976							// triggers after content is added, usually is true when page is refreshed from cache
977							self.ev.trigger('rsMaybeSizeReady', currSlideObject);
978						}, 100);
979					}
980					
981				}
982			};
983			var triggerLoaded = function () {
984				if(!currSlideObject.loadedTriggered && self.ev) {
985					currSlideObject.isLoaded = currSlideObject.loadedTriggered = true;
986					currSlideObject.holder.trigger('rsAfterContentSet');
987					self.ev.trigger('rsAfterContentSet', currSlideObject);
988				}
989			};
990			var setPreloader = function () {
991				if(self.st.usePreloader)
992					currSlideObject.holder.html(self._preloader.clone());
993			};
994			var removePreloader = function (now) {
995				if(self.st.usePreloader) {
996					var preloader = currSlideObject.holder.find('.rsPreloader');
997					if(preloader.length) {
998						preloader.remove();
999					}
1000				}
1001			};
1002
1003			if(currSlideObject.isLoaded) {
1004				appendContent();
1005				return;
1006			} else {
1007				if(beforeTransition) {
1008					waitForTransition();
1009				} else {
1010					parseDataAndLoad();
1011				}
1012			}
1013
1014		},
1015		_addBlockToContainer: function(slideObject, content, dontFade) {
1016			var self = this;
1017			var holder = slideObject.holder;
1018			var bId = slideObject.id - self._newSlideId;
1019			var visibleNearby = false;
1020
1021			self._slidesContainer.append(holder);
1022			slideObject.appendOnLoaded = false;
1023		},
1024	
1025		_onDragStart:function(e, isThumbs) {
1026			var self = this,
1027				point,
1028				wasAnimating,
1029				isTouch = (e.type === 'touchstart');
1030
1031
1032			self._isTouchGesture = isTouch;	
1033
1034			self.ev.trigger('rsDragStart');
1035			if($(e.target).closest('.rsNoDrag', self._currHolder).length) {
1036				self.dragSuccess = false;
1037				return true;
1038			}
1039
1040
1041			if(!isThumbs) {
1042				if(self._isAnimating) {
1043					self._wasAnimating = true;
1044
1045					self._stopAnimation();
1046				}
1047			}
1048			self.dragSuccess = false;
1049			if(self._isDragging) {
1050				if(isTouch) {
1051					self._multipleTouches = true;
1052				}
1053				return;
1054			} else {
1055				if(isTouch) {
1056					self._multipleTouches = false;
1057				}
1058			}
1059

1060			self._setGrabbingCursor();
1061			
1062			if(isTouch) {
1063				//parsing touch event
1064				var touches = e.originalEvent.touches;
1065				if(touches && touches.length > 0) {
1066					point = touches[0];
1067					if(touches.length > 1) {
1068						self._multipleTouches = true;
1069					}
1070				}					
1071				else {	
1072					return;						
1073				}
1074			} else {
1075				e.preventDefault();				
1076				point = e;
1077				if(self.pointerEnabled) point = point.originalEvent;		
1078			}
1079
1080			self._isDragging = true;
1081			self._doc.on(self._moveEvent, function(e) { self._onDragMove(e, isThumbs); })
1082						.on(self._upEvent, function(e) { self._onDragRelease(e, isThumbs); });
1083			
1084			self._currMoveAxis = '';
1085			self._hasMoved = false;
1086			self._pageX = point.pageX;
1087			self._pageY = point.pageY;
1088			self._startPagePos = self._accelerationPos = (!isThumbs ? self._slidesHorizontal : self._thumbsHorizontal) ? point.pageX : point.pageY;
1089			
1090			self._horDir = 0;
1091			self._verDir = 0;
1092
1093			self._currRenderPosition = !isThumbs ? self._sPosition : self._thumbsPosition;
1094
1095			self._startTime = new Date().getTime();
1096			if(isTouch) {
1097				self._sliderOverflow.on(self._cancelEvent, function(e) { self._onDragRelease(e, isThumbs); });	
1098			}
1099		},
1100		_renderMovement:function(point, isThumbs) {
1101			var self = this;
1102			if(self._checkedAxis) {
1103
1104				var timeStamp = self._renderMoveTime,
1105					deltaX = point.pageX - self._pageX,
1106					deltaY = point.pageY - self._pageY,
1107					newX = self._currRenderPosition + deltaX,
1108					newY = self._currRenderPosition + deltaY,
1109					isHorizontal = (!isThumbs ? self._slidesHorizontal : self._thumbsHorizontal),
1110					newPos = isHorizontal ? newX : newY,
1111					mAxis = self._currMoveAxis;
1112
1113				self._hasMoved = true;
1114				self._pageX = point.pageX;
1115				self._pageY = point.pageY;
1116
1117				if(mAxis === 'x' && deltaX !== 0) {
1118					self._horDir = deltaX > 0 ? 1 : -1;
1119				} else if(mAxis === 'y' && deltaY !== 0) {
1120					self._verDir = deltaY > 0 ? 1 : -1;
1121				}
1122

1123				var pointPos = isHorizontal ? self._pageX : self._pageY,
1124					deltaPos = isHorizontal ? deltaX : deltaY;
1125				if(!isThumbs) {
1126					if(!self._loop) {
1127						if(self.currSlideId <= 0) {
1128							if(pointPos - self._startPagePos > 0) {
1129								newPos = self._currRenderPosition + deltaPos * self._lastItemFriction;
1130							}
1131						}
1132						if(self.currSlideId >= self.numSlides - 1) {
1133							if(pointPos - self._startPagePos < 0) {
1134								newPos = self._currRenderPosition + deltaPos * self._lastItemFriction ;
1135							}
1136						}
1137					}
1138				} else {
1139					if(newPos > self._thumbsMinPosition) {
1140						newPos = self._currRenderPosition + deltaPos * self._lastItemFriction;
1141					} else if(newPos < self._thumbsMaxPosition) {
1142						newPos = self._currRenderPosition + deltaPos * self._lastItemFriction ;
1143					}
1144				}
1145
1146				self._currRenderPosition = newPos;
1147				
1148				if (timeStamp - self._startTime > 200) {
1149					self._startTime = timeStamp;
1150					self._accelerationPos = pointPos;						
1151				}
1152
1153				if(!isThumbs) {
1154					if(self._isMove) {
1155						self._setPosition(self._currRenderPosition);
1156					}
1157				} else {
1158					self._setThumbsPosition(self._currRenderPosition);
1159				}
1160			}
1161			
1162		},
1163		_onDragMove:function(e, isThumbs) {
1164			var self = this,
1165				point,
1166				isTouch = (e.type === 'touchmove');
1167
1168			if(self._isTouchGesture && !isTouch) {
1169				return;
1170			}
1171
1172			if(isTouch) {
1173				if(self._lockAxis) {
1174					return;
1175				}	
1176				var touches = e.originalEvent.touches;
1177				if(touches) {
1178					if(touches.length > 1) {
1179						return;
1180					} else {
1181						point = touches[0];	
1182					}
1183				} else {
1184					return;
1185				}
1186			} else {
1187				point = e;
1188				if(self.pointerEnabled) point = point.originalEvent;	
1189			}
1190			
1191
1192			if(!self._hasMoved) {
1193				if(self._useCSS3Transitions) {
1194					(!isThumbs ? self._slidesContainer : self._thumbsContainer).css((self._vendorPref + self._TD), '0s');
1195				}
1196				(function animloop(){
1197					if(self._isDragging) {
1198						self._animFrame = requestAnimationFrame(animloop);
1199						if(self._renderMoveEvent)
1200							self._renderMovement(self._renderMoveEvent, isThumbs);
1201					}
1202					
1203				})();
1204			}
1205				
1206			if(!self._checkedAxis) {
1207				
1208				var dir = (!isThumbs ? self._slidesHorizontal : self._thumbsHorizontal),
1209					diff = (Math.abs(point.pageX - self._pageX) - Math.abs(point.pageY - self._pageY) ) - (dir ? -7 : 7);
1210
1211				if(diff > 7) {
1212					// hor movement
1213					if(dir) {
1214						e.preventDefault();
1215						self._currMoveAxis = 'x';
1216					} else if(isTouch) {
1217						self._completeGesture(e);
1218						return;
1219					} 
1220					self._checkedAxis = true;
1221				} else if(diff < -7) {
1222					// ver movement
1223					if(!dir) {
1224						e.preventDefault();
1225						self._currMoveAxis = 'y';
1226					} else if(isTouch) {
1227						self._completeGesture(e);
1228						return;
1229					} 
1230					self._checkedAxis = true;
1231				}
1232				return;
1233			}
1234			
1235			e.preventDefault();	
1236			self._renderMoveTime = new Date().getTime();
1237			self._renderMoveEvent = point;
1238		},
1239		_completeGesture: function(e, isThumbs) {
1240			var self = this;
1241			self._lockAxis = true;
1242			self._hasMoved = self._isDragging = false;
1243			self._onDragRelease(e);
1244		},
1245		_onDragRelease:function(e, isThumbs) {
1246			var self = this,
1247				totalMoveDist,
1248				accDist,
1249				duration,
1250				v0,
1251				newPos,
1252				newDist,
1253				newDuration,
1254				blockLink,
1255				isTouch = (e.type.indexOf('touch') > -1);
1256
1257
1258
1259
1260			if(self._isTouchGesture && !isTouch) {
1261				return;
1262			}
1263
1264			self._isTouchGesture = false;
1265			self.ev.trigger('rsDragRelease');
1266
1267			self._renderMoveEvent = null;
1268			self._isDragging = false;
1269			self._lockAxis = false;
1270			self._checkedAxis = false;
1271			self._renderMoveTime = 0;
1272			cancelAnimationFrame(self._animFrame);
1273			if(self._hasMoved) {
1274				if(!isThumbs) {
1275					if(self._isMove) {
1276						self._setPosition(self._currRenderPosition);
1277					}
1278				} else {
1279					self._setThumbsPosition(self._currRenderPosition);
1280				}
1281			}
1282
1283
1284			self._doc.off(self._moveEvent).off(self._upEvent);
1285
1286			if(isTouch) {
1287				self._sliderOverflow.off(self._cancelEvent);	
1288			}
1289
1290			

1291			self._setGrabCursor();
1292			if (!self._hasMoved && !self._multipleTouches) {
1293				if(isThumbs && self._thumbsEnabled) {
1294					var item = $(e.target).closest('.rsNavItem');
1295					if(item.length) {
1296
1297						self.goTo(item.index());
1298					}	
1299					return;
1300				}
1301			}
1302			var orient = (!isThumbs ? self._slidesHorizontal : self._thumbsHorizontal);
1303			if(!self._hasMoved || (self._currMoveAxis === 'y' && orient) || (self._currMoveAxis === 'x' && !orient) ) {
1304				if(!isThumbs && self._wasAnimating) {
1305					self._wasAnimating = false;
1306					if(!self.st.navigateByClick) {
1307						self.dragSuccess = true;
1308					} else {
1309						self._mouseNext( (self.pointerEnabled ? e.originalEvent : e) );
1310						self.dragSuccess = true;
1311						return;
1312					}
1313				} else {
1314					self._wasAnimating = false;
1315					self.dragSuccess = false;
1316					return;
1317				}
1318				
1319			} else {
1320				self.dragSuccess = true;
1321			}
1322
1323			self._wasAnimating = false;
1324			
1325			
1326			self._currMoveAxis = '';
1327
1328			
1329			function getCorrectSpeed(newSpeed) {
1330				if(newSpeed < 100) {
1331					return 100;
1332				} else if(newSpeed > 500) {
1333					return 500;
1334				} 
1335				return newSpeed;
1336			}
1337			function returnToCurrent(isSlow, v0) {
1338				if(self._isMove || isThumbs) {
1339
1340					newPos = (-self._realId - self._idOffset) * self._slideSize;
1341					newDist = Math.abs(self._sPosition  - newPos);
1342					self._currAnimSpeed = newDist / v0;
1343					if(isSlow) {
1344						self._currAnimSpeed += 250; 
1345					}
1346					self._currAnimSpeed = getCorrectSpeed(self._currAnimSpeed);
1347
1348					self._animateTo(newPos, false);
1349				}
1350			}
1351
1352			var snapDist = self.st.minSlideOffset,
1353				point = isTouch ? e.originalEvent.changedTouches[0] : (self.pointerEnabled ? e.originalEvent : e),
1354				pPos = orient ? point.pageX : point.pageY,
1355				sPos = self._startPagePos,
1356				axPos = self._accelerationPos,
1357				axCurrItem = self.currSlideId,
1358				axNumItems = self.numSlides,
1359				dir = orient ? self._horDir : self._verDir,
1360				loop = self._loop,
1361				changeHash = false,
1362				distOffset = 0;
1363			
1364			totalMoveDist = Math.abs(pPos - sPos);
1365			accDist = pPos - axPos;
1366
1367
1368			duration = (new Date().getTime()) - self._startTime;
1369			v0 = Math.abs(accDist) / duration;	
1370
1371			if(dir === 0 || axNumItems <= 1) {
1372				returnToCurrent(true, v0);
1373				return;
1374			}
1375
1376			if(!loop && !isThumbs) {
1377				if(axCurrItem <= 0) {
1378					if(dir > 0) {
1379						returnToCurrent(true, v0);
1380						return;
1381					}
1382				} else if(axCurrItem >= axNumItems - 1) {
1383					if(dir < 0) {
1384						returnToCurrent(true, v0);
1385						return;
1386					}
1387				}
1388			}
1389
1390			if(!isThumbs) {
1391
1392				var getSwipedSlides = function(dist) {
1393					var numSwipedSlides = Math.floor(dist / self._slideSize);
1394		            var nextSlideOffset = dist - (numSwipedSlides * self._slideSize);
1395		            if (nextSlideOffset > snapDist) {
1396		                numSwipedSlides++;
1397		            }
1398		            return numSwipedSlides;
1399				};
1400
1401				if(sPos + snapDist < pPos) {
1402					if(dir < 0) {		
1403						returnToCurrent(false, v0);
1404						return;					
1405					}
1406					var swipedSlides = getSwipedSlides(pPos - sPos);
1407					self._moveTo(self.currSlideId-swipedSlides, getCorrectSpeed(Math.abs(self._sPosition  - (-self._realId - self._idOffset + swipedSlides) * self._slideSize) / v0), changeHash, true, true);
1408				} else if(sPos - snapDist > pPos) {
1409					if(dir > 0) {		
1410						returnToCurrent(false, v0);
1411						return;					
1412					}
1413					
1414					var swipedSlides = getSwipedSlides(sPos - pPos);
1415		            self._moveTo(self.currSlideId+swipedSlides, getCorrectSpeed(Math.abs(self._sPosition  - (-self._realId - self._idOffset - swipedSlides) * self._slideSize) / v0), changeHash, true, true);
1416				
1417				} else {
1418					returnToCurrent(false, v0);
1419				}
1420			} else {
1421				newPos = self._thumbsPosition;
1422				var transitionSpeed;
1423				
1424				if(newPos > self._thumbsMinPosition) {
1425					newPos = self._thumbsMinPosition;
1426				} else if(newPos < self._thumbsMaxPosition) {
1427					newPos = self._thumbsMaxPosition;
1428				} else {
1429					var friction = 0.003,
1430						S = (v0 * v0) / (friction * 2),
1431						minXDist = -self._thumbsPosition,
1432						maxXDist = self._thumbsContainerSize - self._thumbsViewportSize + self._thumbsPosition;
1433
1434					if (accDist > 0 && S > minXDist) {
1435						minXDist = minXDist + self._thumbsViewportSize / (15 / (S / v0 * friction));
1436						v0 = v0 * minXDist / S;
1437						S = minXDist;
1438					} else if (accDist < 0 && S > maxXDist) {
1439						maxXDist = maxXDist + self._thumbsViewportSize / (15 / (S / v0 * friction));
1440						v0 = v0 * maxXDist / S;
1441						S = maxXDist;
1442					}
1443
1444
1445
1446
1447					transitionSpeed =  Math.max(Math.round(v0 / friction), 50);
1448					newPos = newPos + S * (accDist < 0 ? -1 : 1);
1449
1450
1451					if(newPos > self._thumbsMinPosition) {
1452						self._animateThumbsTo(newPos, transitionSpeed, true, self._thumbsMinPosition, 200);
1453						return;
1454					} else if(newPos < self._thumbsMaxPosition) {
1455						self._animateThumbsTo( newPos, transitionSpeed, true, self._thumbsMaxPosition, 200);
1456						return;
1457					}
1458				}
1459
1460				self._animateThumbsTo(newPos, transitionSpeed, true);
1461
1462			}
1463		},
1464
1465
1466
1467		_setPosition: function(pos) {
1468			var self = this;
1469			pos = self._sPosition = pos;
1470			if(self._useCSS3Transitions) {
1471				self._slidesContainer.css(self._xProp, self._tPref1 + ( self._slidesHorizontal ? (pos + self._tPref2 + 0) : (0 + self._tPref2 + pos) ) + self._tPref3 );		
1472			} else {
1473				self._slidesContainer.css(self._slidesHorizontal ? self._xProp : self._yProp, pos);
1474			}
1475		},
1476		
1477		
1478		updateSliderSize: function(force) {
1479			var self = this,
1480				newWidth,
1481				newHeight;
1482
1483			if(!self.slider) {
1484				return;
1485			}
1486
1487			if(self.st.autoScaleSlider) {
1488				var asw = self.st.autoScaleSliderWidth,
1489					ash = self.st.autoScaleSliderHeight;
1490
1491				if(self.st.autoScaleHeight) {
1492					newWidth = self.slider.width();
1493					if(newWidth != self.width) {
1494						self.slider.css("height", newWidth * (ash / asw) );
1495						newWidth = self.slider.width();
1496					}	
1497					newHeight = self.slider.height();
1498				} else {
1499					newHeight = self.slider.height();
1500					if(newHeight != self.height) {
1501						self.slider.css("width", newHeight * (asw / ash));
1502						newHeight = self.slider.height();
1503					}		
1504					newWidth = self.slider.width();
1505				}
1506			
1507			} else {
1508				newWidth = self.slider.width();
1509				newHeight = self.slider.height();
1510			}
1511			
1512
1513
1514			if(force || newWidth != self.width || newHeight != self.height) {
1515				self.width = newWidth;
1516				self.height = newHeight;
1517
1518				self._wrapWidth = newWidth;
1519				self._wrapHeight = newHeight;
1520
1521				self.ev.trigger('rsBeforeSizeSet');
1522				self.ev.trigger('rsAfterSizePropSet');
1523
1524				self._sliderOverflow.css({
1525					width: self._wrapWidth,
1526					height: self._wrapHeight
1527				});
1528
1529
1530				self._slideSize = (self._slidesHorizontal ? self._wrapWidth : self._wrapHeight) + self.st.slidesSpacing;
1531				
1532
1533				self._imagePadding = self.st.imageScalePadding;
1534				var item,
1535					slideItem,
1536					i,
1537					img;
1538				for(i = 0; i < self.slides.length; i++) {
1539					item = self.slides[i];

1540					item.positionSet = false;
1541
1542					if(item && item.images && item.isLoaded) {
1543						item.isRendered = false;
1544						self._resizeImage(item);
1545					} 
1546				}
1547				if(self._cloneHolders) {
1548					for(i = 0; i < self._cloneHolders.length; i++) {
1549						item = self._cloneHolders[i];
1550						item.holder.css(self._reorderProp, (item.id + self._idOffset) * self._slideSize);
1551					}
1552				}
1553				
1554				self._updateBlocksContent();
1555
1556				if(self._isMove) {
1557					if(self._useCSS3Transitions) {
1558						self._slidesContainer.css(self._vendorPref + 'transition-duration', '0s');
1559					}
1560					self._setPosition( (-self._realId - self._idOffset) * self._slideSize);
1561				}
1562				self.ev.trigger('rsOnUpdateNav');
1563			}
1564			self._sliderOffset = self._sliderOverflow.offset();
1565			self._sliderOffset = self._sliderOffset[self._reorderProp];
1566
1567
1568		},
1569		
1570		/**
1571		 * Adds slide
1572		 * @param  {jQuery object or raw HTML} htmltext 
1573		 * @param  {int} index    (optional) Index where item should be added (last item is removed of not specified)
1574		 */
1575		appendSlide: function(htmltext, index) {
1576			var self = this,
1577				parsedSlide = self._parseNode(htmltext);
1578
1579			if(isNaN(index) || index > self.numSlides) {
1580				index = self.numSlides;
1581			}
1582			self.slides.splice(index, 0, parsedSlide);
1583			self.slidesJQ.splice(index, 0, $('<div style="'+ (self._isMove ? 'position:absolute;' : self._opacityCSS ) +'" class="rsSlide"></div>') );
1584
1585			if(index <= self.currSlideId) {
1586				self.currSlideId++;
1587			}
1588			self.ev.trigger('rsOnAppendSlide', [parsedSlide, index]);
1589			
1590			self._refreshSlides(index);
1591
1592			if(index === self.currSlideId) {
1593				self.ev.trigger('rsAfterSlideChange');
1594			}
1595		},
1596
1597		/**
1598		 * Removes slide
1599		 * @param  {int} Index of item that should be removed
1600		 */
1601		removeSlide: function(index) {
1602			var self = this,
1603				slideToRemove = self.slides[index];
1604
1605			if(slideToRemove) {
1606				if(slideToRemove.holder) {
1607					slideToRemove.holder.remove();
1608				}
1609				if(index < self.currSlideId) {
1610					self.currSlideId--;
1611				}
1612				self.slides.splice(index, 1);
1613				self.slidesJQ.splice(index, 1);
1614
1615				self.ev.trigger('rsOnRemoveSlide', [index]);
1616				self._refreshSlides(index);
1617
1618				if(index === self.currSlideId) {
1619					self.ev.trigger('rsAfterSlideChange');
1620				}
1621			}
1622		},
1623		_refreshSlides: function(refreshIndex) {
1624
1625			// todo: optimize this stuff
1626			var self = this;
1627
1628			var oldNumSlides = self.numSlides;
1629			var numLoops = self._realId <= 0 ? 0 : Math.floor(self._realId / oldNumSlides);
1630
1631			self.numSlides = self.slides.length;
1632			if(self.numSlides === 0) {
1633				self.currSlideId = self._idOffset = self._realId = 0;
1634				self.currSlide = self._oldHolder = null;
1635			} else {
1636				self._realId = numLoops * self.numSlides + self.currSlideId;
1637			}
1638
1639			for(var i = 0; i < self.numSlides; i++) {
1640				self.slides[i].id = i;
1641			}
1642
1643			self.currSlide = self.slides[self.currSlideId];
1644			self._currHolder = self.slidesJQ[self.currSlideId];
1645
1646			if(self.currSlideId >= self.numSlides) {
1647				self.goTo(self.numSlides - 1);
1648			} else if(self.currSlideId < 0) {
1649				self.goTo(0);
1650			}
1651
1652			self._refreshNumPreloadImages();
1653
1654			if(self._isMove/* && self._loop*/) {
1655				self._slidesContainer.css((self._vendorPref + self._TD), '0ms');
1656			}
1657			if(self._refreshSlidesTimeout) {
1658				clearTimeout(self._refreshSlidesTimeout);
1659			}
1660
1661
1662			self._refreshSlidesTimeout = setTimeout(function() {
1663				if(self._isMove) {
1664					self._setPosition( (-self._realId - self._idOffset) * self._slideSize);	
1665				}
1666				self._updateBlocksContent();
1667				if(!self._isMove) {
1668					self._currHolder.css({
1669						display: 'block',
1670						opacity: 1
1671					});
1672				}
1673				
1674			}, 14);
1675			self.ev.trigger('rsOnUpdateNav');
1676		},
1677		_setGrabCursor:function() {	
1678			var self = this;
1679			if(self._hasDrag && self._isMove) {
1680				if(self._grabCursor) {
1681					self._sliderOverflow.css('cursor', self._grabCursor);
1682				} else {
1683					self._sliderOverflow.removeClass('grabbing-cursor');
1684					self._sliderOverflow.addClass('grab-cursor');	
1685				}
1686			}
1687		},
1688		_setGrabbingCursor:function() {		
1689			var self = this;
1690			if(self._hasDrag && self._isMove) {
1691				if(self._grabbingCursor) {
1692					self._sliderOverflow.css('cursor', self._grabbingCursor);
1693				} else {
1694					self._sliderOverflow.removeClass('grab-cursor');
1695					self._sliderOverflow.addClass('grabbing-cursor');	
1696				}	
1697			}
1698		},
1699		next: function(notUserAction) {
1700			var self = this;
1701			self._moveTo('next',  self.st.transitionSpeed, true, !notUserAction);
1702		},
1703		prev: function(notUserAction) {
1704			var self = this;
1705			self._moveTo('prev', self.st.transitionSpeed, true, !notUserAction);
1706		},
1707		_moveTo:function(type,  speed, inOutEasing, userAction, fromSwipe) {
1708			var self = this,
1709				newPos,
1710				difference,
1711				i,
1712				newItemId;
1713			
1714			
1715			self.ev.trigger('rsBeforeMove', [type, userAction]);
1716			if(type === 'next') {
1717				newItemId = self.currSlideId+1;
1718			} else if(type === 'prev') {
1719				newItemId = self.currSlideId-1;
1720			} else {
1721				newItemId = type = parseInt(type, 10);
1722			}
1723
1724			if(!self._loop) {
1725				if(newItemId < 0) {
1726					self._doBackAndForthAnim('left', !userAction);
1727					return;
1728				} else if(newItemId >= self.numSlides ) {
1729					self._doBackAndForthAnim('right', !userAction);
1730					return;
1731				}
1732			}
1733			
1734			if(self._isAnimating) {
1735				self._stopAnimation(true);
1736				inOutEasing = false;
1737			}
1738
1739			difference = newItemId - self.currSlideId;
1740
1741
1742
1743			self._prevSlideId = self.currSlideId;
1744			var prevId = self.currSlideId;
1745			var id = self.currSlideId + difference;
1746			var realId = self._realId;
1747			var temp;
1748			var delayed;
1749			if(self._loop) {

1750				id = self._updateBlocksContent(false, id);
1751				realId += difference;
1752			} else {
1753				realId = id;
1754			}
1755			self._newSlideId = id;
1756
1757			self._oldHolder = self.slidesJQ[self.currSlideId];
1758
1759			
1760			self._realId = realId;
1761			self.currSlideId = self._newSlideId;
1762
1763			self.currSlide = self.slides[self.currSlideId];
1764			self._currHolder = self.slidesJQ[self.currSlideId];
1765
1766			
1767			var checkDist = self.st.slidesDiff;
1768			var next = Boolean(difference > 0);
1769			var absDiff = Math.abs(difference);
1770			var g1 = Math.floor( prevId / self._numPreloadImages);
1771			var g2 = Math.floor( ( prevId + (next ? checkDist : -checkDist  ) ) / self._numPreloadImages);
1772			var biggest = next ? Math.max(g1,g2) : Math.min(g1,g2);
1773			var biggestId = biggest * self._numPreloadImages +  ( next ? (self._numPreloadImages - 1) : 0 );
1774			if(biggestId > self.numSlides - 1) {
1775				biggestId = self.numSlides - 1;
1776			} else if(biggestId < 0) {
1777				biggestId = 0;
1778			}
1779			var toLast =  next ? (biggestId - prevId) :  (prevId - biggestId);
1780			if(toLast > self._numPreloadImages) {
1781				toLast = self._numPreloadImages;
1782			}
1783			if(absDiff > toLast + checkDist) {
1784				self._idOffset +=  ( absDiff - (toLast + checkDist) ) * ( next ? -1 : 1 );
1785				speed = speed * 1.4;
1786				for(i = 0; i < self.numSlides; i++) {
1787					self.slides[i].positionSet = false;
1788				}
1789			}
1790			self._currAnimSpeed = speed;
1791
1792			self._updateBlocksContent(true);
1793			if(!fromSwipe) {
1794				delayed = true;
1795			}
1796
1797
1798			newPos = (-realId - self._idOffset) * self._slideSize;
1799
1800			
1801
1802			if(delayed) {
1803				setTimeout(function() {
1804					self._isWorking = false;
1805					self._animateTo(newPos, type, false, inOutEasing);
1806					self.ev.trigger('rsOnUpdateNav');
1807				}, 0);
1808			} else {
1809				self._animateTo(newPos, type, false, inOutEasing);
1810				self.ev.trigger('rsOnUpdateNav');
1811			}
1812			
1813			
1814			function isSetToCurrent(testId) {
1815				if(testId < 0) {
1816					testId = self.numSlides + testId;
1817				} else if(testId > self.numSlides - 1) {
1818					testId = testId - self.numSlides;
1819				}
1820				if(testId !== self.currSlideId) {
1821					return false;
1822				}
1823				return true;
1824			}
1825			
1826		},
1827		_updateArrowsNav: function() {
1828			var self = this,
1829				arrDisClass = 'rsArrowDisabled';
1830			if(self.st.arrowsNav) {
1831				if(self.numSlides <= 1) {
1832					self._arrowLeft.css('display', 'none');
1833					self._arrowRight.css('display', 'none');
1834					return;
1835				} else {
1836					self._arrowLeft.css('display', 'block');
1837					self._arrowRight.css('display', 'block');
1838				}
1839				if(!self._loop && !self.st.loopRewind) {
1840					if(self.currSlideId === 0) {
1841						self._arrowLeft.addClass(arrDisClass);
1842					} else {
1843						self._arrowLeft.removeClass(arrDisClass);
1844					}
1845					if(self.currSlideId === self.numSlides - 1) {
1846						self._arrowRight.addClass(arrDisClass);
1847					} else {
1848						self._arrowRight.removeClass(arrDisClass);
1849					}
1850				}
1851			}
1852		},
1853		_animateTo:function(pos, dir,  loadAll, inOutEasing, customComplete) {
1854			var self = this,
1855				moveProp,
1856				oldBlock,
1857				animBlock;
1858
1859			var animObj = {};
1860			if(isNaN(self._currAnimSpeed)) {
1861				self._currAnimSpeed = 400;
1862			} 
1863			
1864
1865
1866			self._sPosition = self._currRenderPosition = pos;
1867
1868			self.ev.trigger('rsBeforeAnimStart');
1869
1870			if(!self._useCSS3Transitions) {
1871				if(self._isMove) {
1872					animObj[self._slidesHorizontal ? self._xProp : self._yProp] = pos + 'px';
1873
1874
1875					self._slidesContainer.animate(animObj, self._currAnimSpeed, /*'easeOutQuart'*/ inOutEasing ? self.st.easeInOut : self.st.easeOut);
1876				} else {
1877					oldBlock = self._oldHolder;
1878					animBlock = self._currHolder;					
1879
1880					animBlock.stop(true, true).css({
1881						opacity: 0,
1882						display: 'block',
1883						zIndex: self._fadeZIndex
1884					});
1885					self._currAnimSpeed = self.st.transitionSpeed;
1886					animBlock.animate({opacity: 1}, self._currAnimSpeed, self.st.easeInOut);
1887
1888					
1889					clearTimeouts();
1890					if(oldBlock) {
1891						oldBlock.data('rsTimeout', setTimeout(function() {
1892							oldBlock.stop(true, true).css({
1893								opacity: 0,
1894								display: 'none',
1895								zIndex: 0
1896							});

1897						}, self._currAnimSpeed + 60) );
1898					}
1899				}
1900				
1901			} else {
1902				if(self._isMove) {
1903					
1904					
1905
1906						self._currAnimSpeed = parseInt(self._currAnimSpeed, 10);
1907						var td = self._vendorPref + self._TD;
1908						var ttf = self._vendorPref + self._TTF;
1909
1910						animObj[td] = self._currAnimSpeed+'ms';
1911						animObj[ttf] = inOutEasing ? $.rsCSS3Easing[self.st.easeInOut] : $.rsCSS3Easing[self.st.easeOut];
1912						
1913						self._slidesContainer.css(animObj);
1914					if(inOutEasing || !self.hasTouch) {
1915						setTimeout(function() {
1916							self._setPosition(pos);
1917						}, 5);
1918					} else {
1919						self._setPosition(pos);
1920					} 
1921					
1922					
1923
1924				} else {
1925					//self._currAnimSpeed = 10
1926					self._currAnimSpeed = self.st.transitionSpeed;
1927					oldBlock = self._oldHolder;
1928					animBlock = self._currHolder;		
1929					if(animBlock.data('rsTimeout')) {
1930						animBlock.css('opacity', 0);
1931					}
1932					clearTimeouts();
1933					if(oldBlock) {
1934						//if(oldBlock)
1935						oldBlock.data('rsTimeout', setTimeout(function() {
1936							animObj[self._vendorPref + self._TD] = '0ms';
1937							animObj.zIndex = 0;
1938							animObj.display = 'none';
1939							oldBlock.data('rsTimeout', '');
1940							oldBlock.css(animObj);
1941							setTimeout(function() {
1942								oldBlock.css('opacity', 0);
1943							}, 16);
1944						}, self._currAnimSpeed + 60) );
1945					}
1946
1947					animObj.display = 'block';
1948					animObj.zIndex = self._fadeZIndex;
1949					animObj.opacity = 0;
1950					animObj[self._vendorPref + self._TD] = '0ms';
1951					animObj[self._vendorPref + self._TTF] = $.rsCSS3Easing[self.st.easeInOut];
1952					animBlock.css(animObj);
1953					animBlock.data('rsTimeout', setTimeout(function() {
1954						//animBlock.css('opacity', 0);
1955						animBlock.css(self._vendorPref + self._TD,  self._currAnimSpeed+'ms');
1956
1957						//oldBlock.css(self._vendorPref + self._TD,  '0ms');
1958						animBlock.data('rsTimeout', setTimeout(function() {
1959							animBlock.css('opacity', 1);
1960							animBlock.data('rsTimeout', '');
1961						}, 20) );
1962					}, 20) );
1963				}
1964			}
1965			self._isAnimating = true;
1966			if(self.loadingTimeout) {
1967				clearTimeout(self.loadingTimeout);
1968			}
1969			if(customComplete) {
1970				self.loadingTimeout = setTimeout(function() {
1971					self.loadingTimeout = null;
1972					customComplete.call();
1973
1974				}, self._currAnimSpeed + 60);
1975			} else {
1976				self.loadingTimeout = setTimeout(function() {
1977					self.loadingTimeout = null;
1978					self._animationComplete(dir);
1979				}, self._currAnimSpeed + 60);
1980			}
1981
1982			function clearTimeouts() {
1983				var t;
1984				if(oldBlock) {
1985					t = oldBlock.data('rsTimeout');
1986					if(t) {
1987						if(oldBlock !== animBlock) {
1988							oldBlock.css({
1989									opacity: 0,
1990									display: 'none',
1991									zIndex: 0
1992								});

1993						}
1994						clearTimeout(t);
1995						oldBlock.data('rsTimeout', '');
1996					}
1997				}
1998				
1999				t = animBlock.data('rsTimeout');
2000				if(t) {
2001					clearTimeout(t);
2002					animBlock.data('rsTimeout', '');
2003				}
2004			}
2005		},
2006		_stopAnimation: function(noCSS3) {
2007			var self = this;
2008			self._isAnimating = false;
2009			clearTimeout(self.loadingTimeout);
2010			if(self._isMove) {
2011
2012				if(!self._useCSS3Transitions) {
2013					self._slidesContainer.stop(true);
2014					self._sPosition = parseInt(self._slidesContainer.css(self._slidesHorizontal ? self._xProp : self._yProp), 10);
2015				} else if (!noCSS3) {
2016					var oldPos = self._sPosition;
2017					var newPos =  self._currRenderPosition = self._getTransformProp();
2018					self._slidesContainer.css((self._vendorPref + self._TD), '0ms');
2019					if(oldPos !==newPos) {
2020						self._setPosition(newPos);
2021					}
2022				}
2023			} else {
2024				// kung fu
2025				if(self._fadeZIndex > 20) {
2026					self._fadeZIndex = 10;
2027				} else {
2028					self._fadeZIndex++;
2029				}
2030			}
2031			
2032			
2033		},
2034		// Thanks to @benpbarnett
2035		_getTransformProp:function(){
2036			var self = this,
2037				transform = window.getComputedStyle(self._slidesContainer.get(0), null).getPropertyValue(self._vendorPref + 'transform'),			
2038				explodedMatrix = transform.replace(/^matrix\(/i, '').split(/, |\)$/g),
2039				isMatrix3d = (explodedMatrix[0].indexOf('matrix3d') === 0);
2040			return parseInt(explodedMatrix[(self._slidesHorizontal ? (isMatrix3d ? 12 : 4) : (isMatrix3d ? 13 : 5) )], 10);
2041		},
2042		_getCSS3Prop: function(pos, hor) {
2043			var self = this;
2044			return self._useCSS3Transitions ? self._tPref1 + ( hor ? (pos + self._tPref2 + 0) : (0 + self._tPref2 + pos) ) + self._tPref3 : pos;
2045		},
2046		_animationComplete: function(dir) {
2047			var self = this;
2048			if(!self._isMove) {
2049				self._currHolder.css('z-index', 0);
2050				self._fadeZIndex = 10;
2051			}
2052			self._isAnimating = false;
2053			
2054			self.staticSlideId = self.currSlideId;
2055			self._updateBlocksContent();
2056
2057
2058			self._slidesMoved = false;
2059			
2060			self.ev.trigger('rsAfterSlideChange');
2061		},
2062		_doBackAndForthAnim:function(type, userAction) {
2063			var self = this,
2064				newPos = (-self._realId - self._idOffset) * self._slideSize;
2065
2066			if(self.numSlides === 0 || self._isAnimating) {
2067				return;
2068			} 
2069			if(self.st.loopRewind) {
2070				self.goTo(type === 'left' ? self.numSlides - 1 : 0, userAction);
2071				return;
2072			}
2073
2074			if(self._isMove) {
2075				self._currAnimSpeed = 200;
2076
2077				var allAnimComplete = function () {
2078					self._isAnimating = false;
2079				};
2080				var firstAnimComplete = function () {
2081					self._isAnimating = false;
2082					self._animateTo(newPos, '', false, true, allAnimComplete);
2083				};
2084				self._animateTo(newPos + (type === 'left' ? 30 : -30),'', false, true, firstAnimComplete);
2085			}
2086			
2087		},
2088
2089		_resizeImage:function(slideObject, useClone) {
2090
2091			var isRoot = true;
2092			if(slideObject.isRendered) {
2093				return;
2094			}
2095			var img = slideObject.content;
2096			var classToFind = 'rsMainSlideImage';
2097			var isVideo;
2098			var self = this,
2099				imgAlignCenter = $.isFunction(self.st.imageAlignCenter) ? self.st.imageAlignCenter(slideObject) : self.st.imageAlignCenter,
2100				imgScaleMode =  $.isFunction(self.st.imageScaleMode) ? self.st.imageScaleMode(slideObject) : self.st.imageScaleMode,
2101				tempEl,
2102				bMargin;
2103
2104			if(slideObject.videoURL) {
2105				classToFind = 'rsVideoContainer';
2106				if(imgScaleMode !== 'fill') {
2107					isVideo = true;
2108				} else {
2109					tempEl = img;
2110					if(!tempEl.hasClass(classToFind)) {
2111						tempEl = tempEl.find('.'+classToFind);
2112					}
2113					tempEl.css({width:'100%',height: '100%'});
2114					classToFind = 'rsMainSlideImage';
2115				}
2116			}
2117			if(!img.hasClass(classToFind)) {
2118				isRoot = false;
2119				img = img.find('.'+classToFind);
2120			}
2121			if(!img) {
2122				return;
2123			}
2124
2125			var baseImageWidth = slideObject.iW,
2126				baseImageHeight = slideObject.iH;
2127
2128			slideObject.isRendered = true;
2129			if(imgScaleMode === 'none' && !imgAlignCenter) {
2130				return;
2131			}
2132			if(imgScaleMode !== 'fill') {
2133				bMargin = self._imagePadding;
2134			} else {
2135				bMargin = 0;
2136			}
2137			//var block = img.parent('.block-inside').css('margin', bMargin);
2138			var containerWidth = self._wrapWidth - bMargin * 2,
2139				containerHeight = self._wrapHeight - bMargin * 2,
2140				hRatio,
2141				vRatio,
2142				ratio,
2143				nWidth,
2144				nHeight,
2145				cssObj = {};
2146
2147			if(imgScaleMode === 'fit-if-smaller') {
2148				if(baseImageWidth > containerWidth || baseImageHeight > containerHeight) {
2149					imgScaleMode = 'fit';
2150				}
2151			}
2152			if(imgScaleMode === 'fill' || imgScaleMode === 'fit') {		
2153				hRatio = containerWidth / baseImageWidth;
2154				vRatio = containerHeight / baseImageHeight;
2155
2156				if (imgScaleMode  == "fill") {
2157					ratio = hRatio > vRatio ? hRatio : vRatio;
2158				} else if (imgScaleMode  == "fit") {
2159					ratio = hRatio < vRatio ? hRatio : vRatio;
2160				} else {
2161					ratio = 1;
2162				}
2163
2164				nWidth = Math.ceil(baseImageWidth * ratio, 10);

2165				nHeight = Math.ceil(baseImageHeight * ratio, 10);
2166			} else {								
2167				nWidth = baseImageWidth;
2168				nHeight = baseImageHeight;		
2169			}
2170			if(imgScaleMode !== 'none') {
2171				cssObj.width = nWidth;
2172				cssObj.height = nHeight;
2173				if(isVideo) {
2174					img.find('.rsImg').css({width: '100%', height:'100%'});
2175				}
2176			}
2177			if (imgAlignCenter) {     
2178				cssObj.marginLeft = Math.floor((containerWidth - nWidth) / 2) +  bMargin;
2179				cssObj.marginTop = Math.floor((containerHeight - nHeight) / 2) +  bMargin;
2180			}
2181			img.css(cssObj);
2182		}
2183	}; /* RoyalSlider core prototype end */
2184	$.rsProto = RoyalSlider.prototype;
2185
2186	$.fn.royalSlider = function(options) {
2187		var args = arguments;
2188		return this.each(function(){
2189			var self = $(this);
2190			if (typeof options === "object" ||  !options) {
2191				if( !self.data('royalSlider') ) {
2192					self.data('royalSlider', new RoyalSlider(self, options));
2193				}
2194			} else {
2195				var royalSlider = self.data('royalSlider');
2196				if (royalSlider && royalSlider[options]) {
2197					return royalSlider[options].apply(royalSlider, Array.prototype.slice.call(args, 1));
2198				}
2199			}
2200		});
2201	};
2202
2203	$.fn.royalSlider.defaults = {    
2204		slidesSpacing: 8,
2205		startSlideId: 0,
2206		loop: false,
2207		loopRewind: false,
2208		numImagesToPreload: 4,
2209		fadeinLoadedSlide: true,
2210		slidesOrientation: 'horizontal',
2211		transitionType: 'move', 
2212		transitionSpeed: 600,
2213		controlNavigation: 'bullets',
2214		controlsInside: true, 
2215		arrowsNav: true,
2216		arrowsNavAutoHide: true,
2217		navigateByClick: true,
2218		randomizeSlides: false,
2219		sliderDrag: true, 
2220		sliderTouch: true,
2221		keyboardNavEnabled: false,
2222		fadeInAfterLoaded: true,
2223
2224		allowCSS3: true,
2225		allowCSS3OnWebkit: true,
2226
2227		
2228		addActiveClass: false,
2229		autoHeight: false,
2230
2231		easeOut: 'easeOutSine',
2232		easeInOut: 'easeInOutSine',
2233
2234		minSlideOffset: 10,
2235
2236		imageScaleMode:"fit-if-smaller",
2237		imageAlignCenter:true,
2238		imageScalePadding: 4,
2239		usePreloader: true,
2240
2241		autoScaleSlider: false,
2242
2243		autoScaleSliderWidth: 800,
2244		autoScaleSliderHeight: 400,
2245
2246		autoScaleHeight: true,
2247
2248		arrowsNavHideOnTouch: false,
2249		globalCaption: false,
2250
2251		slidesDiff: 2
2252	}; /* default options end */
2253
2254	$.rsCSS3Easing = {
2255		easeOutSine: 'cubic-bezier(0.390, 0.575, 0.565, 1.000)',
2256		easeInOutSine: 'cubic-bezier(0.445, 0.050, 0.550, 0.950)'
2257	};
2258
2259	$.extend(jQuery.easing, {
2260		easeInOutSine: function (x, t, b, c, d) {
2261			return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
2262		},
2263		easeOutSine: function (x, t, b, c, d) {
2264			return c * Math.sin(t/d * (Math.PI/2)) + b;
2265		},
2266		easeOutCubic: function (x, t, b, c, d) {
2267			return c*((t=t/d-1)*t*t + 1) + b;
2268		}
2269	});
2270
2271
2272})(jQuery, window);
2273
2274
2275// jquery.rs.active-class v1.0.1
2276(function($) {
2277
2278	"use strict";
2279
2280	/**
2281	 *
2282	 * RoyalSlider active class module 
2283	 * @version 1.0.1:
2284	 *
2285	 * 1.0.1
2286	 * - Simplified code
2287	 * - Fixed bug when slide with activeClass is removed
2288	 */ 
2289	$.rsProto._initActiveClass = function() {
2290		var updClassTimeout,
2291			self = this,
2292			aSlideClass = 'rsActiveSlide';
2293		if(self.st.addActiveClass) {
2294
2295			self.ev.on('rsOnUpdateNav', function() {
2296
2297				if(updClassTimeout) clearTimeout(updClassTimeout);
2298				updClassTimeout = setTimeout(function() {
2299					if(self._oldHolder) self._oldHolder.removeClass(aSlideClass);
2300					if(self._currHolder) self._currHolder.addClass(aSlideClass);
2301					updClassTimeout = null;
2302				}, 50);
2303			});
2304
2305		}
2306	};
2307	$.rsModules.activeClass = $.rsProto._initActiveClass;
2308})(jQuery);
2309
2310// jquery.rs.animated-blocks v1.0.7
2311(function($) {
2312
2313	"use strict";
2314
2315	/**
2316	 *
2317	 * RoyalSlider animated blocks module
2318	 * @version 1.0.7:
2319	 *
2320	 * 1.0.2:
2321	 * - Fixed mistake from prev fix :/
2322	 * 
2323	 * 1.0.3:
2324	 * - Fixed animated block appearing in Firefox
2325	 *
2326	 * 1.0.4
2327	 * - Fixed bug that could cause incorrect block when randomizeSlides is enabled
2328	 *
2329	 * 1.0.5
2330	 * - moveEffect:none' bug
2331	 *
2332	 * 1.0.6
2333	 * - Fixed issue that could cause incorrect position of blocks in IE
2334	 *
2335	 * 1.0.7
2336	 * - Move offset fix
2337	 */ 
2338	$.extend($.rsProto, {
2339		_initAnimatedBlocks: function() {
2340			var self = this,
2341				i;
2342
2343			self._blockDefaults = {
2344				fadeEffect: true,
2345				moveEffect: 'top', 
2346				moveOffset:20,               
2347				speed:400,               
2348				easing:'easeOutSine',      
2349				delay:200                 
2350			};
2351			self.st.block = $.extend({}, self._blockDefaults, self.st.block);
2352
2353			self._blockAnimProps = [];
2354			self._animatedBlockTimeouts = [];
2355
2356			self.ev.on('rsAfterInit', function() {
2357				runBlocks();
2358			});
2359

2360			self.ev.on('rsBeforeParseNode', function(e, content, obj) {
2361				content = $(content);
2362
2363				obj.animBlocks = content.find('.rsABlock').css('display', 'none');
2364				if(!obj.animBlocks.length) {
2365					if(content.hasClass('rsABlock')) {
2366						obj.animBlocks = content.css('display', 'none');
2367					} else {
2368						obj.animBlocks = false;
2369					}
2370				}
2371			});
2372			self.ev.on('rsAfterContentSet', function(e, slideObject) {
2373				var currId = self.slides[self.currSlideId].id; 
2374				if(slideObject.id === currId) {
2375					setTimeout(function() {
2376						runBlocks();
2377					}, self.st.fadeinLoadedSlide ? 300 : 0);
2378				}
2379			});
2380		
2381			self.ev.on('rsAfterSlideChange', function() {
2382				runBlocks();
2383			});
2384			function runBlocks() {
2385				var slide = self.currSlide;
2386				if(!self.currSlide || !self.currSlide.isLoaded) {
2387					return;
2388				}
2389
2390				// clear previous animations
2391				if(self._slideWithBlocks !== slide) {
2392					if(self._animatedBlockTimeouts.length > 0) {
2393						for(i = 0; i < self._animatedBlockTimeouts.length; i++) { 
2394							clearTimeout(self._animatedBlockTimeouts[i]);
2395						}
2396						self._animatedBlockTimeouts = [];
2397					}
2398					
2399					if(self._blockAnimProps.length > 0) {						
2400						var cItemTemp;
2401						for(i = 0; i < self._blockAnimProps.length; i++) {  
2402							cItemTemp = self._blockAnimProps[i];							
2403							if(cItemTemp) {								
2404								if(!self._useCSS3Transitions) {
2405									cItemTemp.block.stop(true).css(cItemTemp.css);
2406								} else {
2407									cItemTemp.block.css(self._vendorPref + self._TD, '0s');
2408									cItemTemp.block.css(cItemTemp.css);
2409								}
2410								self._slideWithBlocks = null;
2411								slide.animBlocksDisplayed = false;
2412							}
2413						}
2414						self._blockAnimProps = [];
2415					}
2416					if(slide.animBlocks) {
2417						slide.animBlocksDisplayed = true;
2418						self._slideWithBlocks = slide;
2419						self._animateBlocks(slide.animBlocks);
2420					}
2421				}
2422			}
2423		},
2424		_updateAnimBlockProps: function(obj, props) {
2425			setTimeout(function() {
2426				obj.css(props);
2427			}, 6);
2428		},
2429		_animateBlocks: function(animBlocks) {
2430			var self = this,
2431				item,
2432				animObj,
2433				newPropObj,
2434				transitionData;
2435
2436			var currItem,
2437				fadeEnabled,
2438				moveEnabled,				
2439				effectName,	
2440				effectsObject,
2441				moveEffectProperty,
2442				currEffects,
2443				newEffectObj,	
2444				moveOffset,
2445				delay,
2446				speed,
2447				easing,
2448				moveProp,
2449				i,
2450				moveEffect,
2451				isOppositeProp;
2452
2453			self._animatedBlockTimeouts = [];
2454
2455			animBlocks.each(function(index) {
2456
2457				item = $(this);
2458				
2459
2460				animObj = {};
2461				newPropObj = {};
2462				transitionData = null;
2463
2464					var moveOffset = item.attr('data-move-offset');
2465					if(!moveOffset) {
2466						moveOffset = self.st.block.moveOffset;
2467					} else {
2468						moveOffset = parseInt(moveOffset, 10);
2469					}
2470
2471					if(moveOffset > 0) {
2472						moveEffect = item.data('move-effect');
2473						if(moveEffect) {
2474							moveEffect = moveEffect.toLowerCase();
2475							if(moveEffect === 'none') {
2476								moveEffect = false;
2477							} else if(moveEffect !== 'left' && moveEffect !== 'top' && moveEffect !== 'bottom' && moveEffect !== 'right') {
2478								moveEffect = self.st.block.moveEffect;
2479								if(moveEffect === 'none') {
2480									moveEffect = false;
2481								}
2482							}
2483						} else {
2484							moveEffect = self.st.block.moveEffect;
2485						}
2486						if(moveEffect && moveEffect !== 'none') {
2487							var moveHorizontal;
2488							if(moveEffect === 'right' || moveEffect === 'left') {
2489								moveHorizontal = true;
2490							} else {
2491								moveHorizontal = false;
2492							}
2493							var currPos,
2494								startPos;
2495							
2496							isOppositeProp = false;
2497							
2498							if(self._useCSS3Transitions) {
2499								currPos = 0;
2500								moveProp = self._xProp;
2501							} else {
2502								if(moveHorizontal) {
2503									if( !isNaN( parseInt(item.css('right'), 10) ) ) {
2504										moveProp = 'right';
2505										isOppositeProp = true;
2506									} else {
2507										moveProp = 'left';
2508									}
2509								} else {
2510
2511									if( !isNaN( parseInt(item.css('bottom'), 10) ) ) {
2512										moveProp = 'bottom';
2513										isOppositeProp = true;
2514									} else {
2515										moveProp = 'top';
2516									}
2517								}
2518								moveProp = 'margin-'+moveProp;
2519								if(isOppositeProp) {
2520									moveOffset = -moveOffset;
2521								}
2522
2523								if(!self._useCSS3Transitions) {
2524									currPos = item.data('rs-start-move-prop');
2525									if( currPos === undefined ) {
2526										currPos = parseInt(item.css(moveProp), 10); 
2527										item.data('rs-start-move-prop', currPos);
2528									}
2529								} else {
2530									currPos = parseInt(item.css(moveProp), 10); 
2531								}
2532								
2533								
2534							}
2535
2536							if(moveEffect === 'top' || moveEffect === 'left') {
2537								startPos = currPos - moveOffset;
2538							} else {
2539								startPos = currPos + moveOffset;
2540							}
2541							
2542							newPropObj[moveProp] = self._getCSS3Prop(startPos, moveHorizontal);
2543							animObj[moveProp] = self._getCSS3Prop(currPos, moveHorizontal);
2544							
2545						}
2546					}
2547					
2548
2549					var fadeEffect = item.attr('data-fade-effect');
2550					if(!fadeEffect) {
2551						fadeEffect = self.st.block.fadeEffect;
2552					} else if(fadeEffect.toLowerCase() === 'none' || fadeEffect.toLowerCase() === 'false') {
2553						fadeEffect = false;
2554					}
2555					if(fadeEffect) {
2556						newPropObj.opacity = 0;
2557						animObj.opacity = 1;
2558					}
2559
2560					if(fadeEffect || moveEffect) {
2561						transitionData = {};
2562						transitionData.hasFade = Boolean(fadeEffect);
2563						if(Boolean(moveEffect)) {
2564							transitionData.moveProp = moveProp;
2565							transitionData.hasMove = true;
2566						}
2567
2568						transitionData.speed = item.data('speed');
2569						if(isNaN(transitionData.speed)) {
2570							transitionData.speed = self.st.block.speed;
2571						}
2572						transitionData.easing = item.data('easing');
2573						if(!transitionData.easing) {
2574							transitionData.easing = self.st.block.easing;
2575						}
2576						transitionData.css3Easing = $.rsCSS3Easing[transitionData.easing];
2577
2578						transitionData.delay =  item.data('delay');
2579						if(isNaN(transitionData.delay)) {
2580							transitionData.delay = self.st.block.delay * index;
2581						}
2582
2583					}
2584
2585					var blockPropsObj = {};
2586					if(self._useCSS3Transitions) {
2587						blockPropsObj[(self._vendorPref + self._TD)] =  '0ms';
2588					}
2589					blockPropsObj.moveProp = animObj.moveProp;
2590					blockPropsObj.opacity = animObj.opacity;
2591					blockPropsObj.display = 'none';
2592
2593
2594					self._blockAnimProps.push({block:item, css:blockPropsObj});
2595
2596					self._updateAnimBlockProps(item, newPropObj);
2597

2598					// animate caption
2599					self._animatedBlockTimeouts.push(setTimeout((function (cItem, animateData, transitionData, index) {	
2600						return function() {	
2601							cItem.css('display', 'block');
2602							if(transitionData) {
2603								var animObj = {};
2604								if(!self._useCSS3Transitions) {
2605									setTimeout(function() {
2606										cItem.animate(animateData, transitionData.speed, transitionData.easing);
2607									}, 16);
2608								} else {
2609									var prop = '';
2610									if(transitionData.hasMove) {
2611										prop += transitionData.moveProp;
2612									} 
2613									if(transitionData.hasFade) {
2614										if(transitionData.hasMove) {
2615											prop += ', ';
2616										}
2617										prop += 'opacity';
2618									}
2619									animObj[(self._vendorPref + self._TP)] = prop;
2620									animObj[(self._vendorPref + self._TD)] =  transitionData.speed + 'ms';
2621									animObj[(self._vendorPref + self._TTF)] = transitionData.css3Easing;
2622									cItem.css(animObj);
2623									setTimeout(function() {
2624										cItem.css(animateData);
2625									}, 24);
2626								}
2627							}
2628					
2629							delete self._animatedBlockTimeouts[index];
2630						};
2631					})(item, animObj, transitionData, index), transitionData.delay <= 6 ? 12 : transitionData.delay));				
2632				//}	
2633
2634
2635
2636			});
2637		}
2638	});
2639	$.rsModules.animatedBlocks = $.rsProto._initAnimatedBlocks;
2640})(jQuery);
2641
2642// jquery.rs.auto-height v1.0.2
2643(function($) {
2644
2645	"use strict";
2646
2647	/**
2648	 *
2649	 * RoyalSlider auto height module
2650	 * @version 1.0.2:
2651	 *
2652	 * 1.0.2
2653	 * - Changed "on" to "one" in afterInit event listener
2654	 * - Removed id="clear"
2655	 */ 
2656	$.extend($.rsProto, {
2657		_initAutoHeight: function() {
2658			var self = this;
2659			if(self.st.autoHeight) {
2660				var holder,
2661					tH,
2662					currSlide,
2663					currHeight,
2664					updHeight = function(animate) {
2665						currSlide = self.slides[self.currSlideId];
2666						holder = currSlide.holder;
2667
2668						if(holder) {
2669							tH = holder.height();
2670							if(tH && tH !== currHeight) {
2671								self._wrapHeight = tH;
2672								if(self._useCSS3Transitions || !animate) {
2673									self._sliderOverflow.css('height', tH);
2674								} else {
2675									self._sliderOverflow.stop(true,true).animate({height: tH}, self.st.transitionSpeed);
2676								}
2677							}
2678						}
2679					};
2680
2681				self.ev.on('rsMaybeSizeReady.rsAutoHeight', function(e, slideObject) {
2682					if(currSlide === slideObject) {
2683						updHeight();
2684					}
2685				});
2686
2687				self.ev.on('rsAfterContentSet.rsAutoHeight', function(e, slideObject) {
2688					if(currSlide === slideObject) {
2689						updHeight();
2690					}
2691				});
2692				
2693
2694
2695				self.slider.addClass('rsAutoHeight');
2696				self.ev.one('rsAfterInit', function() {
2697					setTimeout(function() {
2698						updHeight(false);
2699						setTimeout(function() {
2700							self.slider.append('<div style="clear:both; float: none;"></div>');
2701							if(self._useCSS3Transitions) {
2702								self._sliderOverflow.css(self._vendorPref + 'transition', 'height ' + self.st.transitionSpeed + 'ms ease-in-out');
2703							}
2704						}, 16);
2705					}, 16);
2706				});
2707				self.ev.on('rsBeforeAnimStart', function() {
2708					updHeight(true);
2709				});
2710				self.ev.on('rsBeforeSizeSet' , function() {
2711					setTimeout(function() {
2712						updHeight(false);
2713					}, 16);
2714				});
2715			}
2716			
2717		}
2718	});
2719	$.rsModules.autoHeight = $.rsProto._initAutoHeight;
2720})(jQuery);
2721// jquery.rs.autoplay v1.0.5
2722(function($) {
2723
2724	"use strict";
2725
2726	/**
2727	 *
2728	 * RoyalSlider auto play module
2729	 * @version 1.0.5:
2730	 *
2731	 * 1.0.3:
2732	 * - added support for 'autoplay' property name. 
2733	 *
2734	 * 1.0.4
2735	 * - added toggleAutoPlay public method
2736	 *
2737	 * 1.0.5
2738	 * - Fixed issue when autoPlay may not pause when switching browser tabs
2739	 */
2740	$.extend($.rsProto, {
2741		_initAutoplay: function() {
2742			var self = this,
2743				del;
2744
2745			self._autoPlayDefaults = {
2746				enabled: false,
2747				stopAtAction: true,
2748				pauseOnHover: true,
2749				delay: 2000
2750			};
2751
2752			// fix deprecated name
2753			if(!self.st.autoPlay && self.st.autoplay) {
2754				self.st.autoPlay = self.st.autoplay;
2755			}
2756			self.st.autoPlay = $.extend({}, self._autoPlayDefaults, self.st.autoPlay);
2757
2758			if(self.st.autoPlay.enabled) {

2759				self.ev.on('rsBeforeParseNode', function(e, content, obj) {
2760					content = $(content);
2761					del = content.attr('data-rsDelay');
2762					if(del) {
2763						obj.customDelay = parseInt(del, 10);
2764					}
2765				});
2766				self.ev.one('rsAfterInit', function() {
2767					self._setupAutoPlay();
2768				});
2769				self.ev.on('rsBeforeDestroy', function() {
2770					self.stopAutoPlay();
2771					self.slider.off('mouseenter mouseleave');
2772					$(window).off('blur'+self.ns + ' focus' + self.ns);
2773				});
2774				
2775			}
2776		},
2777		_setupAutoPlay: function() {
2778			var self = this;
2779				
2780			self.startAutoPlay();
2781
2782			self.ev.on('rsAfterContentSet', function(e, slideObject) {
2783				if(!self._isDragging && !self._isAnimating && self._autoPlayEnabled && slideObject === self.currSlide ) {
2784					self._play();
2785				}
2786			});
2787			self.ev.on('rsDragRelease', function() {
2788				if(self._autoPlayEnabled && self._autoPlayPaused) {
2789					self._autoPlayPaused = false;
2790					self._play();
2791				}
2792			});
2793			self.ev.on('rsAfterSlideChange', function() {
2794				if(self._autoPlayEnabled) {
2795					if(self._autoPlayPaused) {
2796						self._autoPlayPaused = false; 
2797
2798						if(self.currSlide.isLoaded) {
2799							self._play();
2800						}
2801					}
2802				}
2803			});
2804			self.ev.on('rsDragStart', function() {
2805				if(self._autoPlayEnabled) {
2806					if(self.st.autoPlay.stopAtAction) {
2807						self.stopAutoPlay();
2808					} else {
2809						self._autoPlayPaused = true;
2810						self._pause();
2811					}
2812				}
2813			});
2814			self.ev.on('rsBeforeMove', function(e, type, userAction) {
2815				if(self._autoPlayEnabled) {
2816					if(userAction && self.st.autoPlay.stopAtAction) {
2817						self.stopAutoPlay();
2818					} else {
2819						self._autoPlayPaused = true;
2820						self._pause();
2821					}
2822				}
2823			});
2824
2825			self._pausedByVideo = false;
2826			self.ev.on('rsVideoStop', function() {
2827				if(self._autoPlayEnabled) {
2828					self._pausedByVideo = false;
2829					self._play();
2830				}
2831			});
2832			self.ev.on('rsVideoPlay', function() {
2833				if(self._autoPlayEnabled) {
2834					self._autoPlayPaused = false;
2835					self._pause();
2836					self._pausedByVideo = true;
2837				} 
2838			});
2839
2840			$(window).on('blur'+self.ns, function(){
2841				if(self._autoPlayEnabled) {
2842					self._autoPlayPaused = true;
2843					self._pause();
2844				}
2845			}).on('focus'+self.ns, function(){
2846				if(self._autoPlayEnabled && self._autoPlayPaused) {
2847					self._autoPlayPaused = false;
2848					self._play();
2849				}
2850			});
2851
2852			if(self.st.autoPlay.pauseOnHover) {
2853				self._pausedByHover = false;
2854				self.slider.hover(
2855					function() {
2856						if(self._autoPlayEnabled) {
2857							self._autoPlayPaused = false;
2858							self._pause();
2859							self._pausedByHover = true;
2860						} 
2861					},
2862					function() {
2863						if(self._autoPlayEnabled) {
2864							self._pausedByHover = false;
2865							self._play();
2866						}
2867					}
2868				);	
2869			}
2870			
2871		},
2872		toggleAutoPlay: function() {
2873			var self = this;
2874			if(self._autoPlayEnabled) {
2875				self.stopAutoPlay();
2876			} else {
2877				self.startAutoPlay();
2878			}
2879		},
2880		startAutoPlay: function() {
2881			var self = this;
2882			self._autoPlayEnabled = true;
2883			if(self.currSlide.isLoaded) {
2884				self._play();
2885			}
2886		},
2887		stopAutoPlay: function() {
2888			var self = this;
2889			self._pausedByVideo = self._pausedByHover = self._autoPlayPaused = self._autoPlayEnabled = false;
2890			self._pause();
2891		},
2892		_play: function() {
2893			var self = this;
2894			if(!self._pausedByHover && !self._pausedByVideo) {
2895				self._autoPlayRunning = true;
2896				if(self._autoPlayTimeout) {
2897					clearTimeout(self._autoPlayTimeout);
2898				}
2899				self._autoPlayTimeout = setTimeout(function() {
2900					var changed;
2901					if(!self._loop && !self.st.loopRewind) {
2902						changed = true;
2903						self.st.loopRewind = true;
2904					}
2905					self.next(true);
2906					if(changed) {
2907						changed = false;
2908						self.st.loopRewind = false;
2909					}
2910				}, !self.currSlide.customDelay ? self.st.autoPlay.delay : self.currSlide.customDelay);
2911			}
2912			
2913		},
2914		_pause: function() {
2915			var self = this;
2916			if(!self._pausedByHover && !self._pausedByVideo) {
2917				self._autoPlayRunning = false;
2918				if(self._autoPlayTimeout) {
2919					clearTimeout(self._autoPlayTimeout);
2920					self._autoPlayTimeout = null;
2921				}
2922			}
2923		}
2924	});
2925	$.rsModules.autoplay = $.rsProto._initAutoplay;
2926})(jQuery);
2927
2928// jquery.rs.bullets v1.0.1
2929(function($) {
2930
2931	"use strict";
2932
2933	/**
2934	 *
2935	 * RoyalSlider bullets module
2936	 * @version 1.0.1:
2937	 *
2938	 * 1.0.1
2939	 * - Minor optimizations
2940	 * 
2941	 */ 
2942	$.extend($.rsProto, {
2943		_initBullets: function() {
2944			var self = this;
2945			if(self.st.controlNavigation === 'bullets') {
2946				var itemHTML = '<div class="rsNavItem rsBullet"><span></span></div>';
2947				self.ev.one('rsAfterPropsSetup', function() {
2948
2949					self._controlNavEnabled = true;
2950					self.slider.addClass('rsWithBullets');
2951					var out = '<div class="rsNav rsBullets">';
2952					for(var i = 0; i < self.numSlides; i++) {
2953						out += itemHTML;
2954					}
2955					self._controlNav = out = $(out + '</div>');
2956					self._controlNavItems = out.appendTo(self.slider).children();

2957
2958					self._controlNav.on('click.rs','.rsNavItem',function(e) {
2959						if(!self._thumbsDrag ) {
2960							self.goTo( $(this).index() );
2961						}
2962					});
2963				});
2964
2965				self.ev.on('rsOnAppendSlide', function(e, parsedSlide, index) {
2966					if(index >= self.numSlides) {
2967						self._controlNav.append(itemHTML);
2968					} else {
2969						self._controlNavItems.eq(index).before(itemHTML);
2970					}
2971					self._controlNavItems = self._controlNav.children();
2972				});
2973				self.ev.on('rsOnRemoveSlide', function(e, index) {
2974					var itemToRemove = self._controlNavItems.eq(index);
2975					if(itemToRemove && itemToRemove.length) {
2976						itemToRemove.remove();
2977						self._controlNavItems = self._controlNav.children();
2978					}
2979					
2980				});	
2981
2982				self.ev.on('rsOnUpdateNav', function() {
2983					var id = self.currSlideId,
2984						currItem,
2985						prevItem;
2986					if(self._prevNavItem) {
2987						self._prevNavItem.removeClass('rsNavSelected');
2988					}
2989					currItem = self._controlNavItems.eq(id);
2990
2991					currItem.addClass('rsNavSelected');
2992					self._prevNavItem = currItem;
2993				});
2994			}
2995		}
2996	});
2997	$.rsModules.bullets = $.rsProto._initBullets;
2998})(jQuery);
2999
3000// jquery.rs.deeplinking v1.0.6 + jQuery hashchange plugin v1.3 Copyright (c) 2010 Ben Alman
3001(function($) {
3002
3003  "use strict";
3004
3005	/**
3006	 *
3007	 * RoyalSlider Deep Linking Module
3008	 * @version 1.0.6 + jQuery hashchange plugin v1.3 Copyright (c) 2010 Ben Alman:
3009   *
3010   * 1.0.1:
3011   * - Added timeout before hash changes to 750ms to avoid reloading animation.
3012   *
3013   * 1.0.2:
3014   * - Added multiple slider with hash support
3015   *
3016   * 1.0.3

3017   * - Removed hashchange listener on destroy()
3018   *
3019   * 1.0.4
3020   * - Decreased timeout from 750 to 400ms
3021   *
3022   * 1.0.5
3023   * - History state is now replaced instead of pushing to avoid back button confusion
3024   * - jQuery 1.9.0 compability
3025   *
3026   * 1.0.6
3027   * - Namespaced hashchange event
3028	 */ 
3029	$.extend($.rsProto, {
3030		_initDeeplinking: function() {
3031			var self = this,
3032        isBlocked,
3033        hashTimeout,
3034        hashChangeTimeout;
3035			
3036			self._hashDefaults = {
3037				enabled: false,
3038				change: false,
3039				prefix: ''
3040			};
3041
3042			self.st.deeplinking = $.extend({}, self._hashDefaults, self.st.deeplinking);
3043
3044			if(self.st.deeplinking.enabled) {
3045
3046				var hashChange = self.st.deeplinking.change,
3047				    prefix = '#' + self.st.deeplinking.prefix,
3048				    getSlideIdByHash = function() {
3049    					var hash = window.location.hash;
3050    					if(hash) {
3051    						hash = parseInt( hash.substring(prefix.length), 10 ); 
3052    						if(hash >= 0) {
3053    							return hash - 1;
3054    						}
3055    					}
3056    					return -1;
3057    				};
3058
3059
3060				var id = getSlideIdByHash();
3061				if(id !== -1) {
3062					self.st.startSlideId = id;
3063				}
3064
3065				if(hashChange) {
3066					$(window).on('hashchange'+self.ns, function(e){
3067						if(!isBlocked) {
3068							var id = getSlideIdByHash();
3069              if(id < 0) {
3070                return;
3071              }
3072              if(id > self.numSlides - 1)
3073                id = self.numSlides - 1;
3074              self.goTo( id );
3075						}
3076					});
3077          self.ev.on('rsBeforeAnimStart', function() {
3078            if(hashTimeout) {
3079              clearTimeout(hashTimeout);
3080            }
3081            if(hashChangeTimeout) {
3082              clearTimeout(hashChangeTimeout);
3083            }
3084          });
3085
3086  				self.ev.on('rsAfterSlideChange', function() {
3087  					if(hashTimeout) {
3088  						clearTimeout(hashTimeout);
3089  					}
3090            if(hashChangeTimeout) {
3091              clearTimeout(hashChangeTimeout);
3092            }
3093            hashChangeTimeout = setTimeout(function() {
3094              isBlocked = true;
3095              window.location.replace( (''+window.location).split('#')[0] + prefix + (self.currSlideId + 1) );
3096              hashTimeout = setTimeout(function() {
3097                isBlocked = false;
3098                hashTimeout = null;
3099              }, 60);
3100            }, 400);
3101  				
3102  				});
3103        }
3104        self.ev.on('rsBeforeDestroy', function() {
3105          hashChangeTimeout = null;
3106          hashTimeout = null;
3107          if(hashChange) {
3108            $(window).off('hashchange' + self.ns);
3109          }
3110        });
3111				
3112			}
3113		}
3114	});
3115	$.rsModules.deeplinking = $.rsProto._initDeeplinking;
3116})(jQuery);
3117
3118/*!
3119 * jQuery hashchange event - v1.3 - 7/21/2010
3120 * http://benalman.com/projects/jquery-hashchange-plugin/
3121 * 
3122 * Copyright (c) 2010 "Cowboy" Ben Alman
3123 * Dual licensed under the MIT and GPL licenses.
3124 * http://benalman.com/about/license/
3125 */
3126(function($,window,undefined){
3127  '$:nomunge'; // Used by YUI compressor.
3128  
3129  // Reused string.
3130  var str_hashchange = 'hashchange',
3131    
3132    // Method / object references.
3133    doc = document,
3134    fake_onhashchange,
3135    special = $.event.special,
3136    
3137    // Does the browser support window.onhashchange? Note that IE8 running in
3138    // IE7 compatibility mode reports true for 'onhashchange' in window, even
3139    // though the event isn't supported, so also test document.documentMode.
3140    doc_mode = doc.documentMode,
3141    supports_onhashchange = 'on' + str_hashchange in window && ( doc_mode === undefined || doc_mode > 7 );
3142  
3143  // Get location.hash (or what you'd expect location.hash to be) sans any
3144  // leading #. Thanks for making this necessary, Firefox!
3145  function get_fragment( url ) {
3146    url = url || location.href;
3147    return '#' + url.replace( /^[^#]*#?(.*)$/, '$1' );
3148  };
3149 
3150  $.fn[ str_hashchange ] = function( fn ) {
3151    return fn ? this.bind( str_hashchange, fn ) : this.trigger( str_hashchange );
3152  };
3153  
3154  $.fn[ str_hashchange ].delay = 50;
3155 
3156  special[ str_hashchange ] = $.extend( special[ str_hashchange ], {
3157    
3158    // Called only when the first 'hashchange' event is bound to window.
3159    setup: function() {
3160      // If window.onhashchange is supported natively, there's nothing to do..
3161      if ( supports_onhashchange ) { return false; }
3162      
3163      // Otherwise, we need to create our own. And we don't want to call this
3164      // until the user binds to the event, just in case they never do, since it
3165      // will create a polling loop and possibly even a hidden Iframe.
3166      $( fake_onhashchange.start );
3167    },
3168    
3169    // Called only when the last 'hashchange' event is unbound from window.
3170    teardown: function() {
3171      // If window.onhashchange is supported natively, there's nothing to do..
3172      if ( supports_onhashchange ) { return false; }
3173      
3174      // Otherwise, we need to stop ours (if possible).
3175      $( fake_onhashchange.stop );
3176    }
3177    
3178  });
3179  
3180  // fake_onhashchange does all the work of triggering the window.onhashchange
3181  // event for browsers that don't natively support it, including creating a

3182  // polling loop to watch for hash changes and in IE 6/7 creating a hidden
3183  // Iframe to enable back and forward.
3184  fake_onhashchange = (function(){
3185    var self = {},
3186      timeout_id,
3187      
3188      // Remember the initial hash so it doesn't get triggered immediately.
3189      last_hash = get_fragment(),
3190      
3191      fn_retval = function(val){ return val; },
3192      history_set = fn_retval,
3193      history_get = fn_retval;
3194    
3195    // Start the polling loop.
3196    self.start = function() {
3197      timeout_id || poll();
3198    };
3199    
3200    // Stop the polling loop.
3201    self.stop = function() {
3202      timeout_id && clearTimeout( timeout_id );
3203      timeout_id = undefined;
3204    };
3205    
3206    // This polling loop checks every $.fn.hashchange.delay milliseconds to see
3207    // if location.hash has changed, and triggers the 'hashchange' event on
3208    // window when necessary.
3209    function poll() {
3210      var hash = get_fragment(),
3211        history_hash = history_get( last_hash );
3212      
3213      if ( hash !== last_hash ) {
3214        history_set( last_hash = hash, history_hash );
3215        
3216        $(window).trigger( str_hashchange );
3217        
3218      } else if ( history_hash !== last_hash ) {
3219        location.href = location.href.replace( /#.*/, '' ) + history_hash;
3220      }
3221      
3222      timeout_id = setTimeout( poll, $.fn[ str_hashchange ].delay );
3223    };
3224    
3225    window.attachEvent && !window.addEventListener && !supports_onhashchange && (function(){
3226      // Not only do IE6/7 need the "magical" Iframe treatment, but so does IE8
3227      // when running in "IE7 compatibility" mode.
3228      
3229      var iframe,
3230        iframe_src;
3231      
3232      // When the event is bound and polling starts in IE 6/7, create a hidden
3233      // Iframe for history handling.
3234      self.start = function(){
3235        if ( !iframe ) {
3236          iframe_src = $.fn[ str_hashchange ].src;
3237          iframe_src = iframe_src && iframe_src + get_fragment();
3238          
3239          // Create hidden Iframe. Attempt to make Iframe as hidden as possible
3240          // by using techniques from http://www.paciellogroup.com/blog/?p=604.
3241          iframe = $('<iframe tabindex="-1" title="empty"/>').hide()
3242            
3243            // When Iframe has completely loaded, initialize the history and
3244            // start polling.
3245            .one( 'load', function(){
3246              iframe_src || history_set( get_fragment() );
3247              poll();
3248            })
3249            
3250            // Load Iframe src if specified, otherwise nothing.
3251            .attr( 'src', iframe_src || 'javascript:0' )
3252            
3253            // Append Iframe after the end of the body to prevent unnecessary
3254            // initial page scrolling (yes, this works).
3255            .insertAfter( 'body' )[0].contentWindow;
3256          
3257          // Whenever `document.title` changes, update the Iframe's title to
3258          // prettify the back/next history menu entries. Since IE sometimes
3259          // errors with "Unspecified error" the very first time this is set
3260          // (yes, very useful) wrap this with a try/catch block.
3261          doc.onpropertychange = function(){
3262            try {
3263              if ( event.propertyName === 'title' ) {
3264                iframe.document.title = doc.title;
3265              }
3266            } catch(e) {}
3267          };
3268          
3269        }
3270      };
3271      
3272      // Override the "stop" method since an IE6/7 Iframe was created. Even
3273      // if there are no longer any bound event handlers, the polling loop
3274      // is still necessary for back/next to work at all!
3275      self.stop = fn_retval;
3276      
3277      // Get history by looking at the hidden Iframe's location.hash.
3278      history_get = function() {
3279        return get_fragment( iframe.location.href );
3280      };
3281      
3282      // Set a new history item by opening and then closing the Iframe
3283      // document, *then* setting its location.hash. If document.domain has
3284      // been set, update that as well.
3285      history_set = function( hash, history_hash ) {
3286        var iframe_doc = iframe.document,
3287          domain = $.fn[ str_hashchange ].domain;
3288        
3289        if ( hash !== history_hash ) {
3290          // Update Iframe with any initial `document.title` that might be set.
3291          iframe_doc.title = doc.title;
3292          
3293          // Opening the Iframe's document after it has been closed is what
3294          // actually adds a history entry.
3295          iframe_doc.open();
3296          
3297          // Set document.domain for the Iframe document as well, if necessary.
3298          domain && iframe_doc.write( '<script>document.domain="' + domain + '"</script>' );
3299          
3300          iframe_doc.close();
3301          
3302          // Update the Iframe's hash, for great justice.
3303          iframe.location.hash = hash;
3304        }
3305      };
3306      
3307    })();
3308    
3309    return self;
3310  })();

3311  
3312})(jQuery,this);
3313
3314// jquery.rs.fullscreen v1.0.5
3315(function($) {
3316
3317	"use strict";
3318
3319	/**
3320	 *
3321	 * RoyalSlider fullscreen module
3322	 * @version 1.0.5:
3323	 *
3324	 * 1.0.1:
3325	 * - Added rsEnterFullscreen and rsExitFullscreen events
3326	 *
3327	 * 1.0.2
3328	 * - Added window scroll detection
3329	 *
3330	 * 1.0.3
3331	 * - Fullscreen button now is added to _controlsContainer element
3332	 *
3333	 * 1.0.4
3334	 * - Fixed issue that could cause small image be loaded in fullscreen
3335	 *
3336	 * 1.0.5
3337	 * - Fix "false" native fullscreen on Android
3338	 * 
3339	 */
3340	$.extend($.rsProto, {
3341		_initFullscreen: function() {
3342			var self = this;
3343
3344			self._fullscreenDefaults = {
3345				enabled: false,
3346				keyboardNav: true,
3347				buttonFS: true,
3348				nativeFS: false,
3349				doubleTap: true
3350			};
3351			self.st.fullscreen = $.extend({}, self._fullscreenDefaults, self.st.fullscreen);
3352
3353			if(self.st.fullscreen.enabled) {
3354				self.ev.one('rsBeforeSizeSet', function() {
3355					self._setupFullscreen();
3356				});
3357			}
3358		},
3359		_setupFullscreen: function() {
3360			var self = this;
3361			self._fsKeyboard = (!self.st.keyboardNavEnabled && self.st.fullscreen.keyboardNav);
3362
3363			if(self.st.fullscreen.nativeFS) {
3364				// Thanks to John Dyer http://j.hn/
3365				self._fullScreenApi = {
3366					supportsFullScreen: false,
3367					isFullScreen: function() { return false; },
3368					requestFullScreen: function() {},
3369					cancelFullScreen: function() {},
3370					fullScreenEventName: '',
3371					prefix: ''
3372				};
3373
3374				var browserPrefixes = 'webkit moz o ms khtml'.split(' ');
3375				// check for native support
3376				if(!self.isAndroid) {
3377					if (typeof document.cancelFullScreen != 'undefined') {
3378						self._fullScreenApi.supportsFullScreen = true;
3379					} else {
3380						// check for fullscreen support by vendor prefix
3381						for (var i = 0; i < browserPrefixes.length; i++ ) {
3382							self._fullScreenApi.prefix = browserPrefixes[i];
3383							if (typeof document[ self._fullScreenApi.prefix + 'CancelFullScreen' ] != 'undefined' ) {
3384								self._fullScreenApi.supportsFullScreen = true;
3385								break;
3386							}
3387						}
3388					}
3389				}
3390			 
3391				// update methods to do something useful
3392				if ( self._fullScreenApi.supportsFullScreen) {
3393					self.nativeFS = true;
3394					self._fullScreenApi.fullScreenEventName =  self._fullScreenApi.prefix + 'fullscreenchange' + self.ns;
3395
3396					self._fullScreenApi.isFullScreen = function() {
3397						switch (this.prefix) {
3398							case '':
3399								return document.fullScreen;
3400							case 'webkit':
3401								return document.webkitIsFullScreen;
3402							default:
3403								return document[this.prefix + 'FullScreen'];
3404						}
3405					};
3406					self._fullScreenApi.requestFullScreen = function(el) {
3407						return (this.prefix === '') ? el.requestFullScreen() : el[this.prefix + 'RequestFullScreen']();
3408					};
3409					self._fullScreenApi.cancelFullScreen = function(el) {
3410						return (this.prefix === '') ? document.cancelFullScreen() : document[this.prefix + 'CancelFullScreen']();
3411					};
3412				} else {
3413					self._fullScreenApi = false;
3414				}
3415			}
3416
3417
3418			if(self.st.fullscreen.buttonFS) {
3419				self._fsBtn = $('<div class="rsFullscreenBtn"><div class="rsFullscreenIcn"></div></div>')
3420					.appendTo(self._controlsContainer)
3421					.on('click.rs', function() {
3422						if(self.isFullscreen) {
3423							self.exitFullscreen();
3424						} else {
3425
3426							self.enterFullscreen();
3427						}
3428					});
3429			}
3430		},
3431		enterFullscreen: function(preventNative) {
3432			var self = this;
3433			if( self._fullScreenApi ) {
3434				if(!preventNative) {
3435					self._doc.on( self._fullScreenApi.fullScreenEventName, function(e) {
3436						if(!self._fullScreenApi.isFullScreen()) {
3437							self.exitFullscreen(true);
3438						} else {
3439							self.enterFullscreen(true);
3440						}
3441					});
3442					self._fullScreenApi.requestFullScreen($('html')[0]);
3443					return;
3444				} else {
3445					self._fullScreenApi.requestFullScreen($('html')[0]);
3446				}
3447			}
3448
3449			if(self._isFullscreenUpdating) {
3450				return;
3451			}
3452			self._isFullscreenUpdating = true;
3453
3454			self._doc.on('keyup' + self.ns + 'fullscreen', function(e) {
3455				if(e.keyCode === 27) {
3456					self.exitFullscreen();
3457				}
3458			});
3459			if(self._fsKeyboard) {
3460				self._bindKeyboardNav();
3461			}
3462
3463			var win = $(window);
3464			self._fsScrollTopOnEnter = win.scrollTop();
3465			self._fsScrollLeftOnEnter = win.scrollLeft();
3466
3467			self._htmlStyle = $('html').attr('style');
3468			self._bodyStyle = $('body').attr('style');
3469			self._sliderStyle = self.slider.attr('style');
3470
3471			$('body, html').css({
3472				overflow: 'hidden',
3473				height: '100%',
3474				width: '100%',
3475				margin: '0',
3476				padding: '0'
3477			});
3478
3479			self.slider.addClass('rsFullscreen');
3480			
3481		
3482			var item,
3483				i;
3484			for(i = 0; i < self.numSlides; i++) {
3485				item = self.slides[i];

3486				
3487				item.isRendered = false;
3488				if(item.bigImage) {
3489					item.isBig = true;
3490					item.isMedLoaded = item.isLoaded;
3491					item.isMedLoading = item.isLoading;
3492					item.medImage = item.image;
3493					item.medIW = item.iW;
3494					item.medIH = item.iH;
3495					item.slideId = -99;
3496
3497					if(item.bigImage !== item.medImage) {
3498						item.sizeType = 'big';
3499					}
3500
3501					item.isLoaded = item.isBigLoaded;
3502					item.isLoading = false;
3503					item.image = item.bigImage;
3504					item.images[0] = item.bigImage;
3505					item.iW = item.bigIW;
3506					item.iH = item.bigIH;
3507
3508					item.isAppended = item.contentAdded = false;
3509					self._updateItemSrc(item);
3510				}
3511				
3512			}
3513
3514			
3515			self.isFullscreen = true;
3516			
3517			self._isFullscreenUpdating = false;
3518			self.updateSliderSize();
3519			self.ev.trigger('rsEnterFullscreen');
3520			
3521		},
3522		exitFullscreen: function(preventNative) {
3523			var self = this;
3524
3525			if( self._fullScreenApi ) {
3526				if(!preventNative) {
3527					self._fullScreenApi.cancelFullScreen($('html')[0]);
3528					return;
3529				}
3530				self._doc.off( self._fullScreenApi.fullScreenEventName );
3531			}
3532			if(self._isFullscreenUpdating) {
3533				return;
3534			}
3535			self._isFullscreenUpdating = true;
3536
3537			self._doc.off('keyup'  + self.ns + 'fullscreen');
3538			if(self._fsKeyboard) {
3539				self._doc.off('keydown' + self.ns);
3540			}
3541
3542			$('html').attr('style', self._htmlStyle || '');
3543			$('body').attr('style', self._bodyStyle || '');
3544			
3545
3546			
3547			var item,
3548				i;
3549			for(i = 0; i < self.numSlides; i++) {
3550				item = self.slides[i];
3551				
3552				
3553				item.isRendered = false;
3554				if(item.bigImage) {
3555					item.isBig = false;
3556					item.slideId = -99;
3557					item.isBigLoaded = item.isLoaded;
3558					item.isBigLoading = item.isLoading;
3559					item.bigImage = item.image;
3560					item.bigIW = item.iW;
3561					item.bigIH = item.iH;
3562					item.isLoaded = item.isMedLoaded;
3563					item.isLoading = false;
3564					item.image = item.medImage;
3565					item.images[0] = item.medImage;
3566					item.iW = item.medIW;
3567					item.iH = item.medIH;
3568
3569					item.isAppended = item.contentAdded = false;
3570
3571					self._updateItemSrc(item, true);
3572					
3573					
3574					if(item.bigImage !== item.medImage) {
3575						item.sizeType = 'med';
3576					}
3577				}
3578			}
3579			
3580			self.isFullscreen = false;
3581
3582			var win = $(window);
3583			win.scrollTop( self._fsScrollTopOnEnter );
3584			win.scrollLeft( self._fsScrollLeftOnEnter );
3585			
3586			self._isFullscreenUpdating = false;
3587			self.slider.removeClass('rsFullscreen');
3588
3589			self.updateSliderSize();
3590			// fix overflow bug
3591			setTimeout(function() {
3592				self.updateSliderSize();
3593			},1);
3594			self.ev.trigger('rsExitFullscreen');
3595		},
3596		_updateItemSrc: function(item, exit) {
3597			var newHTML = (!item.isLoaded && !item.isLoading) ? '<a class="rsImg rsMainSlideImage" href="'+item.image+'"></a>' : '<img class="rsImg rsMainSlideImage" src="'+item.image+'"/>';
3598			
3599			if(item.content.hasClass('rsImg')) {
3600				item.content = $(newHTML);
3601			} else {
3602				item.content.find('.rsImg').eq(0).replaceWith(newHTML);
3603			}
3604			if(!item.isLoaded && !item.isLoading && item.holder) {
3605				item.holder.html(item.content);
3606			}
3607		}
3608	});
3609	$.rsModules.fullscreen = $.rsProto._initFullscreen;
3610})(jQuery);
3611
3612// jquery.rs.global-caption v1.0
3613(function($) {
3614
3615	"use strict";
3616
3617	/**
3618	 *
3619	 * RoyalSlider global caption module
3620	 * @version 1.0:
3621	 * 
3622	 */ 
3623	$.extend($.rsProto, {
3624		_initGlobalCaption: function() {
3625			var self = this;
3626			if(self.st.globalCaption) {
3627				var setCurrCaptionHTML = function () {
3628					self.globalCaption.html(self.currSlide.caption);
3629				};
3630				self.ev.on('rsAfterInit', function() {
3631					self.globalCaption = $('<div class="rsGCaption"></div>').appendTo( !self.st.globalCaptionInside ? self.slider : self._sliderOverflow );
3632					setCurrCaptionHTML();
3633				});
3634				self.ev.on('rsBeforeAnimStart' , function() {
3635					setCurrCaptionHTML();
3636				});
3637			}
3638		}
3639	});
3640	$.rsModules.globalCaption = $.rsProto._initGlobalCaption;
3641})(jQuery);
3642// jquery.rs.nav-auto-hide v1.0
3643(function($) {
3644
3645	"use strict";
3646	
3647	/**
3648	 *
3649	 * RoyalSlider auto hide nav module
3650	 * @version 1.0:
3651	 * 
3652	 */ 
3653	$.extend($.rsProto, {
3654		_initAutoHideControlNav: function() {
3655			var self = this;
3656			if(self.st.navAutoHide && !self.hasTouch) {
3657				self.ev.one('rsAfterInit', function() {
3658					if(self._controlNav) {
3659						self._controlNav.addClass('rsHidden');
3660
3661						var hoverEl = self.slider;
3662						hoverEl.one("mousemove.controlnav",function() {
3663							self._controlNav.removeClass('rsHidden');
3664						});

3665
3666						hoverEl.hover(
3667							function() {
3668								self._controlNav.removeClass('rsHidden');
3669							},
3670							function() {
3671								self._controlNav.addClass('rsHidden');
3672							}
3673						);
3674					}
3675					
3676				});
3677			}
3678		}
3679	});
3680	$.rsModules.autoHideNav = $.rsProto._initAutoHideControlNav;
3681})(jQuery);
3682
3683// jquery.rs.tabs v1.0.2
3684(function($) {
3685
3686	"use strict";
3687	
3688	/**
3689	 *
3690	 * RoyalSlider tabs module
3691	 * @version 1.0.2:
3692	 *
3693	 * 1.0.1:
3694	 * - Dynamic adding/removing tabs.
3695	 *
3696	 * 1.0.2
3697	 * - jQuery 1.9.0 compability
3698	 */ 
3699	$.extend($.rsProto, {
3700		_initTabs: function() {
3701			var self = this;
3702			if(self.st.controlNavigation === 'tabs') {
3703				self.ev.on('rsBeforeParseNode', function(e, content, obj) {
3704					content = $(content);
3705					obj.thumbnail = content.find('.rsTmb').remove();
3706					if(!obj.thumbnail.length) {
3707
3708						obj.thumbnail = content.attr('data-rsTmb');
3709						if(!obj.thumbnail) {
3710							obj.thumbnail = content.find('.rsImg').attr('data-rsTmb');
3711						}
3712						if(!obj.thumbnail) {
3713							obj.thumbnail = '';
3714						} else {
3715							obj.thumbnail = '<img src="'+obj.thumbnail+'"/>';
3716						}
3717					} else {
3718						obj.thumbnail = $(document.createElement('div')).append(obj.thumbnail).html();
3719					}
3720				});
3721
3722				self.ev.one('rsAfterPropsSetup', function() {
3723					self._createTabs();
3724				});
3725
3726				self.ev.on('rsOnAppendSlide', function(e, parsedSlide, index) {
3727					if(index >= self.numSlides) {
3728						self._controlNav.append('<div class="rsNavItem rsTab">' + parsedSlide.thumbnail + '</div>');
3729					} else {
3730						self._controlNavItems.eq(index).before('<div class="rsNavItem rsTab">' + item.thumbnail + '</div>');
3731					}
3732					self._controlNavItems = self._controlNav.children();
3733				});
3734				self.ev.on('rsOnRemoveSlide', function(e, index) {
3735					var itemToRemove = self._controlNavItems.eq(index);
3736					if(itemToRemove) {
3737						itemToRemove.remove();
3738						self._controlNavItems = self._controlNav.children();
3739					}
3740				});	
3741
3742				self.ev.on('rsOnUpdateNav', function() {
3743					var id = self.currSlideId,
3744						currItem,
3745						prevItem;
3746					if(self._prevNavItem) {
3747						self._prevNavItem.removeClass('rsNavSelected');
3748					}
3749
3750					currItem = self._controlNavItems.eq(id);
3751
3752					currItem.addClass('rsNavSelected');
3753					self._prevNavItem = currItem;
3754				});
3755			}
3756			
3757		},
3758		_createTabs: function() {
3759			var self = this, 
3760				out = '',
3761				item;
3762
3763			self._controlNavEnabled = true;
3764			out += '<div class="rsNav rsTabs">';
3765			for(var i = 0; i < self.numSlides; i++) {
3766				out += '<div class="rsNavItem rsTab">'+self.slides[i].thumbnail+'</div>';
3767			}
3768			out += '</div>';
3769
3770			out = $(out);
3771			
3772
3773			self._controlNav = out;
3774			self._controlNavItems = out.children('.rsNavItem');
3775			self.slider.append(out);
3776
3777
3778			self._controlNav.click(function(e) {
3779				var item = $(e.target).closest('.rsNavItem');
3780				if(item.length) {
3781					self.goTo(item.index());
3782				}
3783			});
3784		}
3785	});
3786	$.rsModules.tabs = $.rsProto._initTabs;
3787})(jQuery);
3788
3789// jquery.rs.thumbnails v1.0.5
3790(function($) {
3791
3792	"use strict";
3793
3794	/**
3795	 *
3796	 * RoyalSlider thumbnails module
3797	 * @version 1.0.5:
3798	 *
3799	 * 1.0.1
3800	 * - Fixed bug with vertical thumbs caused by latest update
3801	 * 
3802	 * 1.0.2:
3803	 * - Dynamic adding/removing tabs.
3804	 *
3805	 * 1.0.3
3806	 * - Removed first transition at slider initialization
3807	 *
3808	 * 1.0.4
3809	 * - Added paddingTop & bottom
3810	 * - firstMargin now accepts number which is min distance of first/last thumbnail
3811	 *
3812	 * 1.0.5
3813	 * - IE10 touch support
3814	 *
3815	 */ 
3816	$.extend($.rsProto, {
3817		_initThumbs: function() {
3818			var self = this;
3819			if(self.st.controlNavigation === 'thumbnails') {
3820
3821				self._thumbsDefaults = {
3822					drag: true,
3823					touch: true,
3824					orientation: 'horizontal',
3825					navigation: true,
3826					arrows: true,
3827					arrowLeft: null,
3828					arrowRight: null,
3829					spacing: 4,
3830					arrowsAutoHide: false,
3831					appendSpan: false,
3832					transitionSpeed:600,
3833					autoCenter: true,
3834					fitInViewport: true, 
3835					firstMargin: true,
3836					paddingTop: 0,
3837					paddingBottom: 0
3838				};
3839
3840				self.st.thumbs = $.extend({}, self._thumbsDefaults, self.st.thumbs);
3841				self._firstThumbMoved = true;
3842				if(self.st.thumbs.firstMargin === false) { self.st.thumbs.firstMargin = 0; }
3843				else if(self.st.thumbs.firstMargin === true) { self.st.thumbs.firstMargin = self.st.thumbs.spacing; }
3844

3845				self.ev.on('rsBeforeParseNode', function(e, content, obj) {
3846					content = $(content);
3847					obj.thumbnail = content.find('.rsTmb').remove();
3848					if(!obj.thumbnail.length) {
3849						obj.thumbnail = content.attr('data-rsTmb');
3850						if(!obj.thumbnail) {
3851							obj.thumbnail = content.find('.rsImg').attr('data-rsTmb');
3852						}
3853						if(!obj.thumbnail) {
3854							obj.thumbnail = '';
3855						} else {
3856							obj.thumbnail = '<img src="'+obj.thumbnail+'"/>';
3857						}
3858					} else {
3859						obj.thumbnail = $(document.createElement('div')).append(obj.thumbnail).html();
3860					}
3861				});
3862
3863				self.ev.one('rsAfterPropsSetup', function() {
3864					self._createThumbs();
3865				});
3866
3867				self._prevNavItem = null;
3868				
3869				self.ev.on('rsOnUpdateNav', function() {
3870					var currItem = $(self._controlNavItems[self.currSlideId]);
3871					if(currItem === self._prevNavItem) {
3872						return;
3873					}
3874					if(self._prevNavItem) {
3875						self._prevNavItem.removeClass('rsNavSelected');
3876						self._prevNavItem = null;
3877					}
3878					if(self._thumbsNavigation) {					
3879						self._setCurrentThumb(self.currSlideId);
3880					}
3881					self._prevNavItem = currItem.addClass('rsNavSelected');
3882				});
3883
3884				self.ev.on('rsOnAppendSlide', function(e, parsedSlide, index) {
3885					var html = '<div'+self._thumbsMargin+' class="rsNavItem rsThumb">'+self._addThumbHTML+parsedSlide.thumbnail+'</div>';
3886					if(index >= self.numSlides) {
3887						self._thumbsContainer.append(html);
3888					} else {
3889						self._controlNavItems.eq(index).before(html);
3890					}
3891					self._controlNavItems = self._thumbsContainer.children();
3892					self.updateThumbsSize();
3893				});
3894				self.ev.on('rsOnRemoveSlide', function(e, index) {
3895					var itemToRemove = self._controlNavItems.eq(index);
3896					if(itemToRemove) {
3897						itemToRemove.remove();
3898						self._controlNavItems = self._thumbsContainer.children();
3899						self.updateThumbsSize();
3900					}
3901				});	
3902				
3903
3904			}	
3905		},
3906		_createThumbs: function() {
3907			var self = this, 
3908				tText = 'rsThumbs',
3909				thumbSt = self.st.thumbs,
3910				out = '',
3911				style,
3912				item,
3913				spacing = thumbSt.spacing;
3914			
3915			self._controlNavEnabled = true;
3916			self._thumbsHorizontal = (thumbSt.orientation === 'vertical') ? false : true;
3917			
3918			self._thumbsMargin = style = spacing ? ' style="margin-' + (self._thumbsHorizontal ? 'right' : 'bottom') + ':'+ spacing+'px;"' : ''; 
3919			
3920			self._thumbsPosition = 0;
3921			self._isThumbsAnimating = false;
3922			self._thumbsDrag = false;
3923			self._thumbsNavigation = false;
3924
3925			self._thumbsArrows = (thumbSt.arrows && thumbSt.navigation);
3926
3927			var pl = (self._thumbsHorizontal ? 'Hor' : 'Ver');
3928			self.slider.addClass('rsWithThumbs' + ' rsWithThumbs'+ pl );
3929			
3930			out += '<div class="rsNav rsThumbs rsThumbs'+pl +'"><div class="'+tText+'Container">';
3931			self._addThumbHTML = thumbSt.appendSpan ? '<span class="thumbIco"></span>' : '';
3932			for(var i = 0; i < self.numSlides; i++) {
3933				item = self.slides[i];
3934				out += '<div'+style+' class="rsNavItem rsThumb">'+item.thumbnail+self._addThumbHTML+'</div>';
3935			}

3936			out = $(out +'</div></div>');
3937
3938			var o = {};
3939			if(thumbSt.paddingTop) {
3940				o[self._thumbsHorizontal ? 'paddingTop' : 'paddingLeft'] = thumbSt.paddingTop;
3941			} 
3942			if(thumbSt.paddingBottom) {
3943				o[self._thumbsHorizontal ? 'paddingBottom' : 'paddingRight'] = thumbSt.paddingBottom;
3944			} 
3945			out.css(o);
3946
3947			self._thumbsContainer = $(out).find('.' + tText + 'Container');
3948
3949			if(self._thumbsArrows) {
3950				tText += 'Arrow';
3951				if(thumbSt.arrowLeft) {
3952					self._thumbsArrowLeft = thumbSt.arrowLeft;
3953				} else {
3954					self._thumbsArrowLeft = $('<div class="'+ tText +' ' + tText +'Left"><div class="'+tText+'Icn"></div></div>');
3955					out.append(self._thumbsArrowLeft);
3956				}
3957
3958				if(thumbSt.arrowRight) {
3959					self._thumbsArrowRight = thumbSt.arrowRight;
3960				} else {
3961					self._thumbsArrowRight = $('<div class="'+ tText +' ' + tText +'Right"><div class="'+tText+'Icn"></div></div>');
3962					out.append(self._thumbsArrowRight);
3963				}
3964
3965				
3966				self._thumbsArrowLeft.click(function() {
3967					var viewportSize = Math.floor(self._thumbsViewportSize / self._thumbSize),
3968						thumbId = Math.floor(self._thumbsPosition / self._thumbSize),
3969						newPos = (thumbId + self._visibleThumbsPerView) * self._thumbSize;
3970					self._animateThumbsTo( newPos > self._thumbsMinPosition ? self._thumbsMinPosition : newPos );
3971				});
3972				self._thumbsArrowRight.click(function() {
3973					var viewportSize = Math.floor(self._thumbsViewportSize / self._thumbSize),
3974						thumbId = Math.floor(self._thumbsPosition / self._thumbSize),
3975						newPos = (thumbId - self._visibleThumbsPerView) * self._thumbSize;
3976					self._animateThumbsTo( newPos < self._thumbsMaxPosition ? self._thumbsMaxPosition : newPos );
3977				});
3978				if(thumbSt.arrowsAutoHide && !self.hasTouch) {
3979					self._thumbsArrowLeft.css('opacity', 0);
3980					self._thumbsArrowRight.css('opacity', 0);
3981
3982					out.one("mousemove.rsarrowshover",function() {
3983						if(self._thumbsNavigation) {
3984							self._thumbsArrowLeft.css('opacity', 1);
3985							self._thumbsArrowRight.css('opacity', 1);		
3986						}		
3987					});
3988
3989					out.hover(
3990						function() {
3991							if(self._thumbsNavigation) {
3992								self._thumbsArrowLeft.css('opacity', 1);
3993								self._thumbsArrowRight.css('opacity', 1);
3994							}
3995						},
3996						function() {
3997							if(self._thumbsNavigation) {
3998								self._thumbsArrowLeft.css('opacity', 0);
3999								self._thumbsArrowRight.css('opacity', 0);
4000							}
4001						}
4002					);	
4003				}	
4004			}
4005
4006			self._controlNav = out;
4007			self._controlNavItems = self._thumbsContainer.children();
4008			
4009
4010			if(self.msEnabled && self.st.thumbs.navigation) {
4011				self._thumbsContainer.css('-ms-touch-action', self._thumbsHorizontal ? 'pan-y' : 'pan-x');
4012			}
4013
4014			self.slider.append(out);
4015			
4016			self._thumbsEnabled = true;
4017			self._thumbsSpacing = spacing;
4018
4019			
4020			if(thumbSt.navigation) {
4021				if(self._useCSS3Transitions) {
4022					self._thumbsContainer.css(self._vendorPref + 'transition-property', self._vendorPref + 'transform');
4023				}
4024			}
4025			
4026			self._controlNav.on('click.rs','.rsNavItem',function(e) {
4027				if(!self._thumbsDrag ) {
4028					self.goTo( $(this).index() );
4029				}
4030			});
4031
4032			self.ev.off('rsBeforeSizeSet.thumbs').on('rsBeforeSizeSet.thumbs', function() {
4033				self._realWrapSize = self._thumbsHorizontal ? self._wrapHeight : self._wrapWidth;
4034				self.updateThumbsSize(true);
4035
4036			});
4037
4038			
4039		},
4040		updateThumbsSize: function(isResize) {
4041			var self = this,
4042				firstThumb = self._controlNavItems.first(),
4043				cssObj = {};
4044
4045			var numItems = self._controlNavItems.length;
4046			self._thumbSize = ( self._thumbsHorizontal ? firstThumb.outerWidth() : firstThumb.outerHeight() ) + self._thumbsSpacing;
4047			self._thumbsContainerSize = numItems * self._thumbSize - self._thumbsSpacing;
4048			cssObj[self._thumbsHorizontal ? 'width' : 'height'] = self._thumbsContainerSize + self._thumbsSpacing;
4049			self._thumbsViewportSize = self._thumbsHorizontal ? self._controlNav.width() : self._controlNav.height();
4050			self._thumbsMaxPosition = -(self._thumbsContainerSize - self._thumbsViewportSize) - (self.st.thumbs.firstMargin);
4051			self._thumbsMinPosition = self.st.thumbs.firstMargin;
4052			self._visibleThumbsPerView = Math.floor(self._thumbsViewportSize / self._thumbSize);
4053
4054			if(self._thumbsContainerSize < self._thumbsViewportSize) {
4055				if(self.st.thumbs.autoCenter) {
4056					self._setThumbsPosition((self._thumbsViewportSize - self._thumbsContainerSize) / 2);
4057				}
4058				if(self.st.thumbs.arrows && self._thumbsArrowLeft) {
4059					var arrDisClass = 'rsThumbsArrowDisabled';
4060					self._thumbsArrowLeft.addClass(arrDisClass);
4061					self._thumbsArrowRight.addClass(arrDisClass);
4062				}
4063				self._thumbsNavigation = false;
4064				self._thumbsDrag = false;
4065				self._controlNav.off(self._downEvent);	
4066
4067			} else if(self.st.thumbs.navigation && !self._thumbsNavigation) {
4068				self._thumbsNavigation = true;
4069				if( (!self.hasTouch && self.st.thumbs.drag) ||  (self.hasTouch && self.st.thumbs.touch)) {
4070					self._thumbsDrag = true;
4071					self._controlNav.on(self._downEvent, function(e) { self._onDragStart(e, true); });	
4072				}
4073			}
4074
4075			if(self._useCSS3Transitions) {
4076				cssObj[(self._vendorPref + 'transition-duration')] = '0ms';
4077			}
4078
4079
4080
4081			self._thumbsContainer.css(cssObj);
4082
4083			if(self._thumbsEnabled && (self.isFullscreen || self.st.thumbs.fitInViewport)) {
4084				if(self._thumbsHorizontal) {
4085					self._wrapHeight = self._realWrapSize - self._controlNav.outerHeight();
4086				} else {
4087					self._wrapWidth = self._realWrapSize - self._controlNav.outerWidth();
4088				}
4089			}
4090		},
4091		setThumbsOrientation: function(newPlacement, dontUpdateSize) {
4092			var self = this;
4093			if(self._thumbsEnabled) {
4094				self.st.thumbs.orientation = newPlacement;
4095				self._controlNav.remove();
4096				self.slider.removeClass('rsWithThumbsHor rsWithThumbsVer');
4097				self._createThumbs();
4098				self._controlNav.off(self._downEvent);	
4099				if(!dontUpdateSize) {
4100					self.updateSliderSize(true);
4101				}
4102			}
4103		},
4104		_setThumbsPosition: function(pos) {
4105			var self = this;
4106			self._thumbsPosition = pos;
4107			if(self._useCSS3Transitions) {
4108				self._thumbsContainer.css(self._xProp, self._tPref1 + ( self._thumbsHorizontal ? (pos + self._tPref2 + 0) : (0 + self._tPref2 + pos) ) + self._tPref3 );		
4109			} else {
4110				self._thumbsContainer.css(self._thumbsHorizontal ? self._xProp : self._yProp, pos);
4111			}
4112		},
4113		_animateThumbsTo: function(pos, speed, outEasing, bounceAnimPosition, bounceAnimSpeed) {
4114			var self = this;
4115			if(!self._thumbsNavigation) {
4116				return;
4117			}
4118			if(!speed) {
4119				speed = self.st.thumbs.transitionSpeed;
4120			}
4121			self._thumbsPosition = pos;
4122			if(self._thumbsAnimTimeout) {
4123				clearTimeout(self._thumbsAnimTimeout);
4124			}
4125			if(self._isThumbsAnimating) {
4126				if(!self._useCSS3Transitions) {
4127					self._thumbsContainer.stop();
4128				}
4129				outEasing = true;
4130			}
4131			var animObj = {};
4132			self._isThumbsAnimating = true;
4133			if(!self._useCSS3Transitions) {
4134				animObj[self._thumbsHorizontal ? self._xProp : self._yProp] = pos + 'px';
4135				self._thumbsContainer.animate(animObj, speed, outEasing ? 'easeOutCubic' : self.st.easeInOut);
4136			} else { 
4137				animObj[(self._vendorPref + 'transition-duration')] = speed+'ms';
4138				animObj[(self._vendorPref + 'transition-timing-function')] = outEasing ? $.rsCSS3Easing[self.st.easeOut] : $.rsCSS3Easing[self.st.easeInOut];
4139				self._thumbsContainer.css(animObj);
4140				self._setThumbsPosition(pos);
4141			}
4142			if(bounceAnimPosition) {
4143				self._thumbsPosition = bounceAnimPosition;
4144			}
4145			self._updateThumbsArrows();
4146			
4147			
4148			self._thumbsAnimTimeout = setTimeout(function() {
4149				self._isThumbsAnimating = false;
4150				if(bounceAnimSpeed) {
4151					self._animateThumbsTo(bounceAnimPosition, bounceAnimSpeed, true);
4152					bounceAnimSpeed = null;
4153				}
4154			}, speed);
4155		},
4156		_updateThumbsArrows: function() {
4157			var self = this;
4158			if(self._thumbsArrows) {
4159				var arrDisClass = 'rsThumbsArrowDisabled';
4160				
4161				if(self._thumbsPosition === self._thumbsMinPosition) {
4162					self._thumbsArrowLeft.addClass(arrDisClass);
4163				} else {
4164					self._thumbsArrowLeft.removeClass(arrDisClass);
4165				}
4166				if(self._thumbsPosition === self._thumbsMaxPosition) {
4167					self._thumbsArrowRight.addClass(arrDisClass);
4168				} else {
4169					self._thumbsArrowRight.removeClass(arrDisClass);
4170				}
4171			}
4172		},
4173		_setCurrentThumb: function(id, justSet) {
4174			
4175			var self = this,
4176				incr = 0,
4177				newPos,

4178				nextThumbEndPos = (id * self._thumbSize + self._thumbSize * 2 - self._thumbsSpacing + self._thumbsMinPosition),
4179				thumbId = Math.floor(self._thumbsPosition / self._thumbSize);
4180			
4181			if(!self._thumbsNavigation) {
4182				return;
4183			}
4184			if(self._firstThumbMoved) {
4185				justSet = true;
4186				self._firstThumbMoved = false;
4187			}
4188
4189			if(nextThumbEndPos  + self._thumbsPosition > self._thumbsViewportSize) {
4190				if(id === self.numSlides - 1) {
4191					incr = 1;
4192				}
4193				thumbId = -id + self._visibleThumbsPerView - 2 + incr;
4194				newPos = thumbId * self._thumbSize + (self._thumbsViewportSize % self._thumbSize) + self._thumbsSpacing - self._thumbsMinPosition;
4195			} else {
4196				if(id !== 0) {
4197					if( (id-1) * self._thumbSize <= -self._thumbsPosition + self._thumbsMinPosition && (id-1) <= self.numSlides - self._visibleThumbsPerView) {
4198						thumbId = -id + 1;
4199						newPos = thumbId * self._thumbSize + self._thumbsMinPosition;
4200					}
4201				} else {
4202					thumbId = 0;
4203					newPos = self._thumbsMinPosition;
4204				}
4205			}
4206
4207			if(newPos !== self._thumbsPosition) {
4208				var checkPos = (newPos === undefined) ? self._thumbsPosition : newPos;
4209				if(checkPos > self._thumbsMinPosition) {
4210					self._setThumbsPosition(self._thumbsMinPosition);
4211				} else if(checkPos < self._thumbsMaxPosition) {
4212					self._setThumbsPosition(self._thumbsMaxPosition);
4213				} else  if(newPos !== undefined) {
4214					if(!justSet) {
4215						self._animateThumbsTo(newPos);
4216					} else {
4217						self._setThumbsPosition(newPos);
4218					}
4219				}
4220			}
4221			self._updateThumbsArrows();
4222		}
4223	});
4224	$.rsModules.thumbnails = $.rsProto._initThumbs;
4225})(jQuery);
4226
4227// jquery.rs.video v1.1.1
4228(function($) {
4229
4230	"use strict";
4231
4232	/**
4233	 *
4234	 * RoyalSlider video module
4235	 * @version 1.1.1:
4236	 *
4237	 * 1.0.3:
4238	 * - Added rsOnDestroyVideoElement event
4239	 *
4240	 * 1.0.4:
4241	 * - Added wmode=transparent to default YouTube video embed code
4242	 *
4243	 * 1.0.5
4244	 * - Fixed bug: HTMl5 YouTube player sometimes keeps playing in ie9 after closing
4245	 *
4246	 * 1.0.6
4247	 * - A bit lightened Vimeo and YouTube regex 
4248	 *
4249	 * 1.0.7
4250	 * - Minor optimizations
4251	 * - Added autoHideCaption option
4252	 *
4253	 * 1.0.9
4254	 * - Fixed error that could appear if updateSliderSize method is called directly after video close
4255	 *
4256	 * 1.1.0
4257	 * - Video is now removed in rsAfterSlideChange event to avoid transition lag
4258	 * - Fixed bug that could cause appearing of arrows with auto-hide
4259	 *
4260	 * 1.1.1
4261	 * - Added option disableCSS3inFF
4262	 */
4263	$.extend($.rsProto, {
4264		_initVideo: function() {
4265			var self = this;
4266			self._videoDefaults = {
4267				autoHideArrows: true,
4268				autoHideControlNav: false,
4269				autoHideBlocks: false,
4270				autoHideCaption: false,
4271				disableCSS3inFF: true,
4272				youTubeCode: '<iframe src="http://www.youtube.com/embed/%id%?rel=1&autoplay=1&showinfo=0&autoplay=1&wmode=transparent" frameborder="no"></iframe>',
4273				vimeoCode: '<iframe src="http://player.vimeo.com/video/%id%?byline=0&amp;portrait=0&amp;autoplay=1" frameborder="no" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>'
4274			};
4275
4276			self.st.video = $.extend({}, self._videoDefaults, self.st.video);
4277
4278			self.ev.on('rsBeforeSizeSet', function() {
4279				if(self._isVideoPlaying) {
4280					setTimeout(function() {
4281						var content = self._currHolder;
4282						content = content.hasClass('rsVideoContainer') ? content : content.find('.rsVideoContainer');
4283						if(self._videoFrameHolder) {
4284							self._videoFrameHolder.css({
4285								width: content.width(),
4286								height: content.height()
4287							});
4288						}
4289					}, 32);
4290				}
4291			});
4292			var isFF = self._browser.mozilla;
4293			self.ev.on('rsAfterParseNode', function(e, content, obj) {
4294				var jqcontent = $(content),
4295					tempEl,
4296					hasVideo;
4297
4298				if(obj.videoURL) {
4299					if(self.st.video.disableCSS3inFF && !hasVideo && isFF) {
4300						hasVideo = true;
4301						self._useCSS3Transitions = self._use3dTransform = false;
4302					}
4303					var wrap = $('<div class="rsVideoContainer"></div>'),
4304						playBtn = $('<div class="rsBtnCenterer"><div class="rsPlayBtn"><div class="rsPlayBtnIcon"></div></div></div>');
4305					if(jqcontent.hasClass('rsImg')) {
4306						obj.content = wrap.append(jqcontent).append(playBtn);
4307					} else {
4308						obj.content.find('.rsImg').wrap(wrap).after(playBtn);
4309					}
4310				}
4311			});
4312
4313			self.ev.on('rsAfterSlideChange', function() {
4314				self.stopVideo();
4315			});
4316
4317		},
4318		toggleVideo: function() {
4319			var self = this;
4320			if(!self._isVideoPlaying) {
4321				return self.playVideo();
4322			} else {
4323				return self.stopVideo();
4324			}
4325		},
4326		playVideo: function() {
4327			var self = this;
4328			if(!self._isVideoPlaying) {
4329				var currSlide = self.currSlide;
4330				if(!currSlide.videoURL) {
4331					return false;
4332				}
4333
4334				
4335				var content = self._currVideoContent = currSlide.content;
4336				var url = currSlide.videoURL,
4337					videoId,
4338					regExp,
4339					match;
4340
4341				if( url.match(/youtu\.be/i) || url.match(/youtube\.com/i) ) {
4342
4343					regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#\&\?]*).*/;
4344
4345
4346					match = url.match(regExp);
4347					if (match && match[7].length==11){
4348						videoId = match[7];
4349					}
4350
4351					if(videoId !== undefined) {
4352						self._videoFrameHolder = self.st.video.youTubeCode.replace("%id%", videoId);
4353					}
4354				} else if(url.match(/vimeo\.com/i)) {
4355					regExp = /(www\.)?vimeo.com\/(\d+)($|\/)/;
4356					match = url.match(regExp);
4357					if(match) {
4358						videoId = match[2];
4359					}
4360					if(videoId !== undefined) {
4361						self._videoFrameHolder = self.st.video.vimeoCode.replace("%id%", videoId);
4362					}
4363				}
4364				self.videoObj = $(self._videoFrameHolder);
4365
4366				self.ev.trigger('rsOnCreateVideoElement', [url]);
4367
4368
4369				if(self.videoObj.length) {

4370					self._videoFrameHolder = $('<div class="rsVideoFrameHolder"><div class="rsPreloader"></div><div class="rsCloseVideoBtn"><div class="rsCloseVideoIcn"></div></div></div>');
4371					self._videoFrameHolder.find('.rsPreloader').after(self.videoObj);
4372					content = content.hasClass('rsVideoContainer') ? content : content.find('.rsVideoContainer');
4373					self._videoFrameHolder.css({
4374						width: content.width(),
4375						height: content.height()
4376					}).find('.rsCloseVideoBtn').off('click.rsv').on('click.rsv', function(e) {
4377						self.stopVideo();
4378						e.preventDefault();
4379						e.stopPropagation();
4380						return false;
4381					});
4382					content.append(self._videoFrameHolder);
4383					if(self.isIPAD) {
4384						content.addClass('rsIOSVideo');
4385					}
4386
4387					self._toggleHiddenClass(false);
4388
4389					setTimeout(function() {
4390						self._videoFrameHolder.addClass('rsVideoActive');
4391					}, 10);
4392					self.ev.trigger('rsVideoPlay');
4393					self._isVideoPlaying = true;
4394				}
4395				return true;
4396			}
4397			return false;
4398		},
4399		stopVideo: function() {
4400			var self = this;
4401			if(self._isVideoPlaying) {
4402				if(self.isIPAD) {
4403					self.slider.find('.rsCloseVideoBtn').remove();
4404				}
4405				
4406				self._toggleHiddenClass(true);
4407
4408				setTimeout(function() {
4409					self.ev.trigger('rsOnDestroyVideoElement', [self.videoObj]);
4410					var ifr = self._videoFrameHolder.find('iframe');
4411					if(ifr.length) {
4412						try {
4413							ifr.attr('src', "");
4414						} catch(ex) { }
4415					}
4416					self._videoFrameHolder.remove();
4417					self._videoFrameHolder = null;
4418				}, 16);
4419				self.ev.trigger('rsVideoStop');
4420				self._isVideoPlaying = false;
4421				return true;
4422			} 
4423			return false;
4424		},
4425		_toggleHiddenClass: function(remove) {
4426			var arr = [],
4427				self = this,
4428				vst = self.st.video;
4429			if(vst.autoHideArrows) {
4430				if(self._arrowLeft) {
4431					arr.push(self._arrowLeft, self._arrowRight);
4432					self._arrowsAutoHideLocked = !remove;
4433				}
4434				if(self._fsBtn) {
4435					arr.push(self._fsBtn);
4436				}
4437			}
4438			if(vst.autoHideControlNav && self._controlNav) {
4439				arr.push(self._controlNav);
4440			}
4441			if(vst.autoHideBlocks && self.currSlide.animBlocks) {
4442				arr.push(self.currSlide.animBlocks);
4443			}
4444			if(vst.autoHideCaption && self.globalCaption) {
4445				arr.push(self.globalCaption);
4446			}
4447
4448			if(arr.length) {
4449				for(var i = 0; i < arr.length; i++) {
4450					if(!remove) {
4451						arr[i].addClass('rsHidden');
4452					} else {
4453						arr[i].removeClass('rsHidden');
4454					}
4455				}
4456			}
4457		}
4458	});
4459	$.rsModules.video = $.rsProto._initVideo;
4460})(jQuery);
4461
4462// jquery.rs.visible-nearby v1.0.2
4463(function($) {
4464
4465	"use strict";
4466
4467	/**
4468	 *
4469	 * RoyalSlider module that makes nearby slides visible
4470	 * @version 1.0.2:
4471	 *
4472	 * 1.0.1
4473	 * - Added navigateByCenterClick, breakpoint options
4474	 *
4475	 * 1.0.2
4476	 * - Added hiddenOverflow option
4477	 *
4478	 */ 
4479	$.rsProto._initVisibleNearby = function() {
4480		var self = this;
4481		if(self.st.visibleNearby && self.st.visibleNearby.enabled) {
4482			self._vnDefaults = {
4483				enabled: true,
4484				centerArea: 0.6, // Area of center image. By default 60% will get center image, 20% for each image on side
4485
4486				center: true,
4487
4488				breakpoint: 0, // this option will be trigger change of centerArea parameter
4489				breakpointCenterArea: 0.8,
4490
4491				hiddenOverflow: true,
4492				navigateByCenterClick: false
4493			};
4494			self.st.visibleNearby = $.extend({}, self._vnDefaults, self.st.visibleNearby);
4495
4496			self.ev.one('rsAfterPropsSetup', function() {
4497				self._sliderVisibleNearbyWrap = self._sliderOverflow.css('overflow', 'visible').wrap('<div class="rsVisibleNearbyWrap"></div>').parent();
4498				if(!self.st.visibleNearby.hiddenOverflow) {
4499					self._sliderVisibleNearbyWrap.css('overflow', 'visible');
4500				}
4501				self._controlsContainer = self.st.controlsInside ? self._sliderVisibleNearbyWrap : self.slider;
4502			});
4503
4504			self.ev.on('rsAfterSizePropSet', function() {
4505				var centerRatio,
4506					o = self.st.visibleNearby;
4507
4508				if(o.breakpoint && self.width < o.breakpoint) {
4509					centerRatio = o.breakpointCenterArea;
4510				} else {
4511					centerRatio = o.centerArea;
4512				}
4513				if(self._slidesHorizontal) {
4514					self._wrapWidth = self._wrapWidth * centerRatio;
4515					self._sliderVisibleNearbyWrap.css({
4516						height: self._wrapHeight,
4517						width: self._wrapWidth / centerRatio
4518					});

4519					self._minPosOffset = self._wrapWidth * (1 - centerRatio) / 2 / centerRatio;
4520				} else {
4521					self._wrapHeight = self._wrapHeight * centerRatio;
4522					self._sliderVisibleNearbyWrap.css({
4523						height: self._wrapHeight / centerRatio,
4524						width: self._wrapWidth
4525					});
4526					self._minPosOffset = self._wrapHeight * (1 - centerRatio) / 2 / centerRatio;
4527				}
4528				if(!o.navigateByCenterClick) {
4529					self._nextSlidePos = self._slidesHorizontal ? self._wrapWidth : self._wrapHeight;
4530				}
4531				if(o.center) {
4532					self._sliderOverflow.css('margin-' + (self._slidesHorizontal ? 'left' : 'top' ), self._minPosOffset);
4533				}
4534			});
4535
4536		}
4537	};
4538	$.rsModules.visibleNearby = $.rsProto._initVisibleNearby;
4539})(jQuery);
4540
4541
4542})(jQuery18);