https://www.refugiodelinza.com/wp-content/themes/dt-the7/royalslider/jquery.royalslider.js?ver=4.2.3.1

1/*
2 * RoyalSlider
3 *
4 * @version 9.4.8:
5 *
6 * Copyright 2011-2012, Dmitry Semenov
7 *
8 */
9(function($) {
10	if(!$.rsModules) {
11		$.rsModules = {uid:0};
12	}
13
14
15	function RoyalSlider(element, options) {
16		var i,
17			self = this,
18			ua = navigator.userAgent.toLowerCase();
19
20		self.uid = $.rsModules.uid++;
21		self.ns = '.rs' + self.uid; // unique namespace for events
22		// feature detection, some ideas taken from Modernizr
23		var tempStyle = document.createElement('div').style,
24			vendors = ['webkit','Moz','ms','O'],
25			vendor = '',
26			lastTime = 0,
27			tempV;
28
29		for (i = 0; i < vendors.length; i++ ) {
30			tempV = vendors[i];
31			if (!vendor && (tempV + 'Transform') in tempStyle ) {
32				vendor = tempV;
33			}
34			tempV = tempV.toLowerCase();
35			
36			if(!window.requestAnimationFrame) {
37				window.requestAnimationFrame = window[tempV+'RequestAnimationFrame'];
38       			window.cancelAnimationFrame = window[tempV+'CancelAnimationFrame'] 
39                                   || window[tempV+'CancelRequestAnimationFrame'];
40			}
41		}
42
43 		// requestAnimationFrame polyfill by Erik Möller
44		// fixes from Paul Irish and Tino Zijdel
45	    if (!window.requestAnimationFrame) {
46	        window.requestAnimationFrame = function(callback, element) {
47	            var currTime = new Date().getTime(),
48	            	timeToCall = Math.max(0, 16 - (currTime - lastTime)),
49	            	id = window.setTimeout(function() { callback(currTime + timeToCall); }, timeToCall);
50	            lastTime = currTime + timeToCall;
51	            return id;
52	        };
53	    }
54	    if (!window.cancelAnimationFrame) 
55	    	window.cancelAnimationFrame = function(id) { clearTimeout(id); };
56
57	    self.isIPAD = ua.match(/(ipad)/);
58
59
60	    // browser UA sniffing, sadly still required
61	    var uaMatch = function( ua ) {
62		    var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
63		        /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
64		        /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
65		        /(msie) ([\w.]+)/.exec( ua ) ||
66		        ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
67		        [];
68
69		    return {
70		        browser: match[ 1 ] || "",
71		        version: match[ 2 ] || "0"
72		    };
73		};
74		var matched = uaMatch( ua );
75		var br = {};
76		if ( matched.browser ) {
77		    br[ matched.browser ] = true;
78		    br.version = matched.version;
79		}
80		if(br.chrome) { br.webkit = true; };
81		self._browser = br;
82		self.isAndroid = ua.indexOf("android") > -1;
83
84
85
86	    self.slider = $(element); // DOM reference
87		self.ev = $(self); // event object
88		self._doc = $(document);
89		self.st = $.extend({}, $.fn.royalSlider.defaults, options); 
90		self._currAnimSpeed = self.st.transitionSpeed;
91 		self._minPosOffset = 0;
92		if(self.st.allowCSS3) {
93			if((!br.webkit || self.st.allowCSS3OnWebkit) ) {
94		    	var bT = vendor + (vendor ? 'T' : 't' );
95		    	self._useCSS3Transitions = ( (bT + 'ransform') in tempStyle ) && ( (bT + 'ransition') in tempStyle );
96			    if(self._useCSS3Transitions) {
97			    	self._use3dTransform = (vendor + (vendor ? 'P' : 'p'  ) + 'erspective') in tempStyle;
98			    }
99		    }
100		}
101	    
102	    vendor = vendor.toLowerCase();
103	    self._vendorPref = '-'+vendor+'-';
104		
105		self._slidesHorizontal = (self.st.slidesOrientation === 'vertical') ? false : true;
106		self._reorderProp = self._slidesHorizontal ? 'left' : 'top';
107		self._sizeProp = self._slidesHorizontal ? 'width' : 'height';
108		self._prevNavItemId = -1;
109		self._isMove = (self.st.transitionType === 'fade') ? false : true;
110		if(!self._isMove) {
111			self.st.sliderDrag = false;
112			self._fadeZIndex = 10;
113		}
114		self._opacityCSS = 'z-index:0; display:none; opacity:0;';
115
116		self._newSlideId = 0;
117		self._sPosition = 0;
118		self._nextSlidePos = 0;
119
120		// init modules
121		$.each($.rsModules, function (helper, opts) {
122			if(helper !== 'uid')
123				opts.call(self);
124		});
125
126		// parse all slides
127		self.slides = [];
128		self._idCount = 0;
129		var returnVal;
130		var ts = self.st.slides ? $(self.st.slides) : self.slider.children().detach();
131		
132		ts.each(function() {
133			self._parseNode(this, true);
134		});
135
136		if(self.st.randomizeSlides) {
137	    	self.slides.sort(function() { return 0.5 - Math.random() });
138	    }
139		self.numSlides = self.slides.length;
140		self._refreshNumPreloadImages();
141
142		if(!self.st.startSlideId) {
143			self.st.startSlideId = 0;
144		} else if(self.st.startSlideId > self.numSlides - 1) {
145			self.st.startSlideId = self.numSlides - 1;
146		}
147
148		self._newSlideId = self.staticSlideId = self.currSlideId = self._realId =  self.st.startSlideId;
149		self.currSlide = self.slides[self.currSlideId];
150
151		self._accelerationPos = 0;
152		self.msTouch = false;

153		self.slider.addClass( (self._slidesHorizontal ? 'rsHor' : 'rsVer') + (self._isMove ? '' : ' rsFade') );
154
155		var sliderHTML = '<div class="rsOverflow"><div class="rsContainer">';
156		self.slidesSpacing = self.st.slidesSpacing;
157		self._slideSize = ( self._slidesHorizontal ? self.slider.width() : self.slider.height() ) + self.st.slidesSpacing;
158
159		self._preload = Boolean(self._numPreloadImages > 0);
160		
161		if(self.numSlides <= 1) {
162			self._loop = false;
163		}
164		var loopHelpers = (self._loop && self._isMove) ? ( self.numSlides === 2 ? 1 : 2) : 0;
165		self._loopHelpers = loopHelpers;
166
167		self._maxImages = self.numSlides < 6 ? self.numSlides : 6;
168		self._currBlockIndex = 0;
169
170
171		self._idOffset = 0;
172		self.slidesJQ = [];
173		
174		for(i =0; i < self.numSlides; i++) {
175			self.slidesJQ.push( $(createItemHTML(i)) );
176		}
177		self._sliderOverflow = sliderHTML = $(sliderHTML + '</div></div>');
178
179
180		var addCursors = function() {
181			if(self.st.sliderDrag) {
182				self._hasDrag = true;
183				if (br.msie || br.opera) {
184					self._grabCursor = self._grabbingCursor = "move";
185				} else if(br.mozilla) {
186					self._grabCursor = "-moz-grab";
187					self._grabbingCursor = "-moz-grabbing";
188				} else if(br.webkit && (navigator.platform.indexOf("Mac")!=-1)) {
189					self._grabCursor = "-webkit-grab";
190					self._grabbingCursor = "-webkit-grabbing";
191				}
192				self._setGrabCursor();
193			}
194		};
195		var rsNS = self.ns;
196		var addEventNames = function(pref, down, move, up, cancel) {
197			self._downEvent = pref + down + rsNS;
198			self._moveEvent = pref + move + rsNS;
199			self._upEvent = pref + up + rsNS;
200			if(cancel)
201				self._cancelEvent = pref + cancel + rsNS;
202		};
203
204
205		// ie10
206		self.msEnabled = window.navigator.msPointerEnabled;
207
208		if(self.msEnabled) {
209			self.msTouch = Boolean(window.navigator.msMaxTouchPoints > 1);
210			self.hasTouch = false;
211			self._lastItemFriction = 0.2;
212			
213			addEventNames('MSPointer', 'Down', 'Move', 'Up', 'Cancel');
214		} else {
215			addEventNames('mouse', 'down', 'move', 'up', 'up');
216
217			if('ontouchstart' in window || 'createTouch' in document) {
218				self.hasTouch = true;
219				self._downEvent += ' touchstart' + rsNS;
220				self._moveEvent += ' touchmove' + rsNS;
221				self._upEvent += ' touchend' + rsNS;
222				self._cancelEvent += ' touchcancel' + rsNS;
223				self._lastItemFriction = 0.5;
224				if(self.st.sliderTouch) {
225					self._hasDrag = true;
226				}
227			} else {
228				self.hasTouch = false;
229				self._lastItemFriction = 0.2;
230			}
231		}
232		addCursors();
233	
234		self.slider.html(sliderHTML);
235
236		
237		self._controlsContainer = self.st.controlsInside ? self._sliderOverflow : self.slider;
238		
239		self._slidesContainer = self._sliderOverflow.children('.rsContainer');
240		if(self.msEnabled) {
241			self._slidesContainer.css('-ms-touch-action', self._slidesHorizontal ? 'pan-y' : 'pan-x');
242		}
243		self._preloader = $('<div class="rsPreloader"><svg class="fa-spinner" viewBox="0 0 48 48" ><path d="M23.98,0.04c-13.055,0-23.673,10.434-23.973,23.417C0.284,12.128,8.898,3.038,19.484,3.038c10.76,0,19.484,9.395,19.484,20.982c0,2.483,2.013,4.497,4.496,4.497c2.482,0,4.496-2.014,4.496-4.497C47.96,10.776,37.224,0.04,23.98,0.04z M23.98,48c13.055,0,23.673-10.434,23.972-23.417c-0.276,11.328-8.89,20.42-19.476,20.42	c-10.76,0-19.484-9.396-19.484-20.983c0-2.482-2.014-4.496-4.497-4.496C2.014,19.524,0,21.537,0,24.02C0,37.264,10.736,48,23.98,48z"/></svg></div>');
244		var slides = self._slidesContainer.children('.rsSlide');
245
246		self._currHolder = self.slidesJQ[self.currSlideId]
247		self._selectedSlideHolder = 0;
248
249		function createItemHTML(i, className) {
250			return '<div style="'+ (self._isMove ? '' : (i !== self.currSlideId  ? self._opacityCSS : 'z-index:0;') ) +'" class="rsSlide '+ (className || '')+'"></div>';
251		}
252		
253		if(self._useCSS3Transitions) {
254
255			// some constants for CSS3
256			self._TP = 'transition-property';
257			self._TD = 'transition-duration';
258			self._TTF = 'transition-timing-function';
259
260			self._yProp = self._xProp = self._vendorPref +'transform';
261
262			if(self._use3dTransform) {
263				if(br.webkit && !br.chrome) {
264					self.slider.addClass('rsWebkit3d');
265				}
266
267				self._tPref1 = 'translate3d(';
268				self._tPref2 = 'px, ';
269				self._tPref3 = 'px, 0px)';
270			} else {
271				self._tPref1 = 'translate(';
272				self._tPref2 = 'px, ';
273				self._tPref3 = 'px)';
274			}
275			if(!self._isMove) {
276				var animObj = {};
277				animObj[(self._vendorPref + self._TP)] = 'opacity';
278				animObj[(self._vendorPref + self._TD)] = self.st.transitionSpeed + 'ms';
279				animObj[(self._vendorPref + self._TTF)] = self.st.css3easeInOut;
280				slides.css(animObj);
281			} else {
282				self._slidesContainer[(self._vendorPref + self._TP)] = (self._vendorPref + 'transform');
283			}
284			
285
286		} else {
287			self._xProp = 'left';
288			self._yProp = 'top';
289		}
290
291
292
293		// !Responsiveness (on window resize)
294		
295		if (!self.st.disableResponsiveness) {
296			var resizeTimer;
297			$(window).on('resize'+self.ns, function() {	
298				if(resizeTimer) {
299					clearTimeout(resizeTimer);			
300				}
301				resizeTimer = setTimeout(function() { self.updateSliderSize(); }, 50);			
302			});
303		}
304
305		self.ev.trigger('rsAfterPropsSetup'); // navigation (bullets, thumbs...) are created here
306
307		self.updateSliderSize();
308
309
310		// keyboard nav
311		if(self.st.keyboardNavEnabled) {
312			self._bindKeyboardNav();
313		}
314
315		if(self.st.arrowsNavHideOnTouch && (self.hasTouch || self.msTouch) ) {
316			self.st.arrowsNav = false;

317		}
318
319		//Direction navigation (arrows)
320		if(self.st.arrowsNav) {
321			var rArr = 'rsArrow',
322				container = self._controlsContainer;
323			$('<div class="'+rArr+' '+rArr+'Left"><div class="'+rArr+'Icn"></div></div><div class="'+rArr+' '+rArr+'Right"><div class="'+rArr+'Icn"></div></div>').appendTo(container);
324
325			self._arrowLeft = container.children('.'+rArr+'Left').click(function(e) {
326				e.preventDefault();
327				self.prev();
328			});
329			self._arrowRight = container.children('.'+rArr+'Right').click(function(e) {
330				e.preventDefault();
331				self.next();
332			});
333
334			if(self.st.arrowsNavAutoHide && !self.hasTouch) {
335				self._arrowLeft.addClass('rsHidden');
336				self._arrowRight.addClass('rsHidden');
337
338				var hoverEl = container;
339				hoverEl.one("mousemove.arrowshover",function() {
340					self._arrowLeft.removeClass('rsHidden');
341					self._arrowRight.removeClass('rsHidden');			
342				});
343
344
345				hoverEl.hover(
346					function() {
347						if(!self._arrowsAutoHideLocked) {
348							self._arrowLeft.removeClass('rsHidden');
349							self._arrowRight.removeClass('rsHidden');
350						}
351					},
352					function() {
353						if(!self._arrowsAutoHideLocked) {
354							self._arrowLeft.addClass('rsHidden');
355							self._arrowRight.addClass('rsHidden');
356						}
357					}
358				);	
359			}	
360			self.ev.on('rsOnUpdateNav', function() {
361				self._updateArrowsNav();
362			});
363			self._updateArrowsNav();
364		}
365
366			
367		
368		if( self._hasDrag ) {
369			self._slidesContainer.on(self._downEvent, function(e) { self._onDragStart(e); });	
370		} else {
371			self.dragSuccess = false;
372		}
373		var videoClasses = ['rsPlayBtnIcon', 'rsPlayBtn', 'rsCloseVideoBtn', 'rsCloseVideoIcn'];
374		self._slidesContainer.click(function(e) {
375			if(!self.dragSuccess) {
376				var t = $(e.target);
377				var tClass = t.attr('class');
378				if( $.inArray(tClass, videoClasses) !== -1) {
379			        if( self.toggleVideo() ) {
380						return false;
381					}
382			    }
383				if(self.st.navigateByClick && !self._blockActions) {
384					if($(e.target).closest('.rsNoDrag', self._currHolder).length) {
385						 return true;
386					}
387					self._mouseNext(e);
388				} 
389				self.ev.trigger('rsSlideClick');
390			} 
391		}).on('click.rs', 'a', function(e) {	
392			if(self.dragSuccess) {						
393				return false;
394			} else {
395				self._blockActions = true;
396				//e.stopPropagation();
397				//e.stopImmediatePropagation();
398				setTimeout(function() {
399					self._blockActions = false;
400				}, 3);
401			}
402		});
403		self.ev.trigger('rsAfterInit');
404	} /* RoyalSlider Constructor End */
405
406	/**
407	 *
408	 * RoyalSlider Core Prototype
409	 * 
410	 */
411	RoyalSlider.prototype = {
412		constructor: RoyalSlider,
413		_mouseNext: function(e) {
414			var self = this,
415				relativePos = e[self._slidesHorizontal ? 'pageX' : 'pageY'] - self._sliderOffset;
416
417		  	if(relativePos >= self._nextSlidePos) {
418		  		self.next();
419		  	} else if(relativePos < 0) {
420		  		self.prev();
421		  	}
422		},
423		_refreshNumPreloadImages: function() {
424			var self = this,
425				n;
426			n = self.st.numImagesToPreload;
427			self._loop = self.st.loop;
428
429			if(self._loop) {
430				if(self.numSlides === 2) {
431					self._loop = false;
432					self.st.loopRewind = true;
433				} else if(self.numSlides < 2) {
434					self.st.loopRewind = self._loop = false;
435				}
436				
437			}
438			if(self._loop && n > 0) {
439				if(self.numSlides <= 4) {
440					n = 1;
441				} else {
442					if(self.st.numImagesToPreload > (self.numSlides - 1) / 2 ) {
443						n = Math.floor( (self.numSlides - 1) / 2 );
444					}
445				} 
446			}
447			self._numPreloadImages = n;
448		},
449		_parseNode: function(content, pushToSlides) {
450			var self = this,
451				hasImg,
452				isRoot,
453				hasCover,
454				obj = {},
455				tempEl,
456				first = true;
457			content = $(content);
458			self._currContent = content;
459			self.ev.trigger('rsBeforeParseNode', [content, obj]);
460			if(obj.stopParsing) {
461				return;
462			}
463			content = self._currContent;
464			obj.id = self._idCount;
465			obj.contentAdded = false;
466			self._idCount++;
467			obj.images = [];
468			obj.isBig = false;
469
470			if(!obj.hasCover) {
471				if(content.hasClass('rsImg')) {
472					tempEl = content;
473					hasImg = true;
474				} else {
475					tempEl = content.find('.rsImg');
476					if(tempEl.length) {
477						hasImg = true;
478					}
479				}
480
481				if(hasImg) {
482					obj.bigImage = tempEl.eq(0).attr('data-rsBigImg');
483					tempEl.each(function() {
484						var item = $(this);
485						if(item.is('a')) {
486							parseEl(item, 'href');
487						} else if(item.is('img')) {
488							parseEl(item, 'src');
489						} else {
490							parseEl(item);
491						}
492					});
493				} else if(content.is('img')) {
494					content.addClass('rsImg rsMainSlideImage');
495					parseEl(content, 'src');
496				}
497			}
498			tempEl = content.find('.rsCaption');
499			if(tempEl.length) {
500				obj.caption = tempEl.remove();
501			}
502			obj.content = content;
503
504			self.ev.trigger('rsAfterParseNode', [content, obj]);
505			function parseEl(el, s) {
506				if(s) {
507					obj.images.push( el.attr(s) );
508				} else {
509					obj.images.push( el.text() );
510				}
511				if(first) {
512					first = false;

513					obj.caption = (s === 'src') ? el.attr('alt') : el.contents();
514					obj.image = obj.images[0];
515					obj.videoURL = el.attr('data-rsVideo');
516					
517					
518					var wAtt = el.attr('data-rsw'),
519						hAtt = el.attr('data-rsh');
520					if (typeof wAtt !== 'undefined' && wAtt !== false && typeof hAtt !== 'undefined' && hAtt !== false ) {
521						   obj.iW = parseInt(wAtt);
522						   obj.iH = parseInt(hAtt);
523					} else if(self.st.imgWidth && self.st.imgHeight ) {
524						obj.iW = self.st.imgWidth;
525						obj.iH = self.st.imgHeight;
526					}
527				}
528			}
529			if(pushToSlides) {
530				self.slides.push(obj);
531			}
532			if(obj.images.length === 0) {
533				obj.isLoaded = true;
534				obj.isRendered = false;
535				obj.isLoading = false;
536				obj.images = null;
537			}
538			return obj;
539		},
540		_bindKeyboardNav: function() {
541			var self = this,
542				interval,
543				keyCode,
544				onKeyboardAction = function (keyCode) {
545				    if (keyCode === 37) {
546						self.prev();
547					} else if (keyCode === 39) {
548						self.next();
549					}
550				};
551
552			self._doc.on('keydown' + self.ns, function(e) {
553				if(!self._isDragging) {
554					keyCode = e.keyCode;
555					if(keyCode === 37 || keyCode === 39) {
556						if(!interval) {
557					        onKeyboardAction(keyCode);
558					        interval = setInterval(function() {
559					            onKeyboardAction(keyCode);
560					        }, 700);
561					    }
562					}
563				}
564			}).on('keyup' + self.ns, function(e) {
565				if(interval) {
566					clearInterval(interval); 
567			   	    interval = null;
568				}
569			});
570
571			
572			
573		},
574
575
576
577
578		goTo: function(id, notUserAction) {
579			var self = this;
580			if(id !== self.currSlideId) {
581				self._moveTo(id,self.st.transitionSpeed, true, !notUserAction);
582			}
583		},
584		destroy: function(remove) {
585			var self = this;
586			self.ev.trigger('rsBeforeDestroy');
587			self._doc.off('keydown' +self.ns+ ' keyup' + self.ns + ' ' + self._moveEvent +' '+ self._upEvent );
588			self._slidesContainer.off(self._downEvent + ' click');	
589			self.slider.data('royalSlider', null);
590			$.removeData(self.slider, 'royalSlider');
591			$(window).off('resize' + self.ns);
592			if(remove) {
593				self.slider.remove();
594			}
595			self.slides = null;
596			self.slider = null;
597			self.ev = null;
598		},
599		_updateBlocksContent: function(beforeTransition, getId) {
600			var self = this,
601				item,
602				i,
603				n,
604				pref,
605				group,
606				groupId,
607				slideCode,
608				loop = self._loop,
609				numSlides = self.numSlides;
610			if(!isNaN(getId) ) {
611				return getCorrectLoopedId(getId);
612			}
613
614
615			var id = self.currSlideId;
616			var groupOffset;
617			
618			var itemsOnSide = beforeTransition ? (Math.abs(self._prevSlideId - self.currSlideId) >= self.numSlides - 1 ? 0 : 1) : self._numPreloadImages;
619			var itemsToCheck = Math.min(2, itemsOnSide); 
620			
621			var updateAfter = false;
622			var updateBefore = false;
623			var tempId;
624
625
626			
627			for(i = id; i < id + 1 + itemsToCheck; i++) {
628				tempId = getCorrectLoopedId(i);
629				item = self.slides[tempId];
630				if(item && (!item.isAdded || !item.positionSet) ) {
631					updateAfter = true;
632					break;
633				}
634			}
635			for(i = id - 1; i > id - 1 - itemsToCheck; i--) {
636				tempId = getCorrectLoopedId(i);
637				item = self.slides[tempId];
638				if(item && (!item.isAdded || !item.positionSet) ) {
639					updateBefore = true;
640					break;
641				}
642			}
643			if(updateAfter) {
644				for(i = id; i < id + itemsOnSide + 1; i++) {
645					tempId = getCorrectLoopedId(i);
646					groupOffset = Math.floor( (self._realId - (id - i)) / self.numSlides) * self.numSlides;
647					item = self.slides[tempId];
648					if(item) {
649						updateItem(item, tempId);	
650					}
651				}
652			}
653			if(updateBefore) {
654				for(i = id - 1; i > id - 1 - itemsOnSide; i--) {
655					tempId = getCorrectLoopedId(i);
656					groupOffset = Math.floor( (self._realId - (id - i) ) / numSlides) * numSlides;
657					item = self.slides[tempId];
658					if(item) {
659						updateItem(item, tempId);
660					}
661				}
662			}
663			if(!beforeTransition) {
664				var start = id;
665				var distance = itemsOnSide;
666				var min = getCorrectLoopedId(id - itemsOnSide);
667				var max = getCorrectLoopedId(id + itemsOnSide);
668				
669				var nmin = min > max ? 0 : min;
670				
671				for (i = 0; i < numSlides; i++) { 
672					if(min > max) {
673						if(i > min - 1) {
674							continue;
675						}
676					}
677					if(i < nmin || i > max) {
678						 item = self.slides[i];
679						if(item && item.holder) {
680							
681							//slideCode = self.slidesJQ[i];
682							//if(typeof slideCode !== "string") { 
683								item.holder.detach();
684								item.isAdded = false;

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

877				    currSlideObject.iH = img.height;
878				    if(currSlideObject.iW && currSlideObject.iH) {
879			    		imageLoadingComplete();
880			    		return;
881			    	} else {
882			    		// if no size, try again
883			    		var loader = new Image();
884			    		loader.onload = function() {
885			    			if(loader.width) {
886			    				currSlideObject.iW = loader.width;
887				    			currSlideObject.iH = loader.height;
888				    			imageLoadingComplete();
889			    			} else {
890			    				setTimeout(function() {
891			    					if(loader.width) {
892			    						currSlideObject.iW = loader.width;
893				    					currSlideObject.iH = loader.height;
894			    					}
895
896			    					// failed to get size on last tier, just output image
897			    					imageLoadingComplete();
898			    				}, 1000);
899			    			}
900						};
901					    loader.src = img.src;
902			    	}
903			    } else {
904			    	imageLoadingComplete();
905			    }
906			}
907			function imageLoadingComplete() {
908				currSlideObject.isLoaded = true;
909				currSlideObject.isLoading = false;
910
911			    appendContent();
912			    removePreloader();
913			    triggerLoaded();
914			}
915			function waitForTransition() {
916				if(!self._isMove && currSlideObject.images && currSlideObject.iW && currSlideObject.iH) {
917					parseDataAndLoad();
918					return;
919				}
920				currSlideObject.holder.isWaiting = true;
921				setPreloader();
922				currSlideObject.holder.slideId = -99;
923			}
924			
925			function appendContent() {
926				if(!currSlideObject.isAppended) {
927
928					var visibleNearby = self.st.visibleNearby,
929					bId = currSlideObject.id - self._newSlideId;
930					if(!beforeTransition && !currSlideObject.appendOnLoaded && self.st.fadeinLoadedSlide  && ( bId === 0 || ( (visibleNearby || self._isAnimating || self._isDragging) && (bId === -1 || bId === 1) ) ) ) {
931						var css = {
932							visibility: 'visible', 
933							opacity: 0
934						};
935						css[self._vendorPref + 'transition'] = 'opacity 400ms ease-in-out';
936						currSlideObject.content.css(css);
937
938						setTimeout(function() {
939							currSlideObject.content.css('opacity', 1);
940						}, 16);
941					}
942
943					if(currSlideObject.holder.find('.rsPreloader').length) {
944						currSlideObject.holder.append( currSlideObject.content );
945					} else {
946						currSlideObject.holder.html( currSlideObject.content );
947					}
948					
949
950					currSlideObject.isAppended = true;
951					if(currSlideObject.isLoaded) {
952						self._resizeImage(currSlideObject);
953						triggerLoaded();
954					}
955					if(!currSlideObject.sizeReady) {
956						currSlideObject.sizeReady = true;
957						setTimeout(function() {
958							// triggers after content is added, usually is true when page is refreshed from cache
959							self.ev.trigger('rsMaybeSizeReady', currSlideObject);
960						}, 100);
961					}
962					
963				}
964			}
965			function triggerLoaded() {
966				if(!currSlideObject.loadedTriggered) {
967					currSlideObject.isLoaded = currSlideObject.loadedTriggered = true;
968					currSlideObject.holder.trigger('rsAfterContentSet');
969		 			self.ev.trigger('rsAfterContentSet', currSlideObject);
970				}
971			}
972			function setPreloader() {
973				if(self.st.usePreloader)
974					currSlideObject.holder.html(self._preloader.clone());
975			}
976			function removePreloader(now) {
977				if(self.st.usePreloader) {
978					var preloader = currSlideObject.holder.find('.rsPreloader');
979					if(preloader.length) {
980						preloader.remove();
981					}
982				}
983			}
984
985		},
986		_addBlockToContainer: function(slideObject, content, dontFade) {
987			var self = this;
988			var holder = slideObject.holder;
989			var bId = slideObject.id - self._newSlideId;
990			
991			var visibleNearby = false;
992			// if(self._isMove && !dontFade && self.st.fadeinLoadedSlide  && ( bId === 0 || ( (visibleNearby || self._isAnimating || self._isDragging) && (bId === -1 || bId === 1) ) ) ) {
993			// 	var content = slideObject.content;
994			// 	content.css(self._vendorPref + 'transition', 'opacity 400ms ease-in-out').css({visibility: 'visible', opacity: 0});
995			// 	//holder.css('opacity', 0);
996			// 	self._slidesContainer.append(holder);
997			// 	setTimeout(function() {
998			// 		content.css('opacity', 1);
999			// 		//self.ev.trigger('rsAfterContentSet', holder);
1000			// 	}, 6);
1001			// } else {
1002				self._slidesContainer.append(holder);
1003			//}
1004			slideObject.appendOnLoaded = false;

1005		},
1006	
1007		_onDragStart:function(e, isThumbs) {
1008			var self = this,
1009				point,
1010				wasAnimating,
1011				isTouch = (e.type === 'touchstart');
1012
1013			self._isTouchGesture = isTouch;	
1014
1015			self.ev.trigger('rsDragStart');
1016			if($(e.target).closest('.rsNoDrag', self._currHolder).length) {
1017				 self.dragSuccess = false;
1018				 return true;
1019			}
1020
1021			
1022
1023			if(!isThumbs) {
1024				if(self._isAnimating) {
1025					self._wasAnimating = true;
1026
1027					self._stopAnimation();
1028				}
1029			}
1030			self.dragSuccess = false;
1031			if(self._isDragging) {
1032				if(isTouch) {
1033					self._multipleTouches = true;
1034				}
1035				return;
1036			} else {
1037				if(isTouch) {
1038					self._multipleTouches = false;
1039				}
1040			}
1041
1042			self._setGrabbingCursor();
1043			
1044			if(isTouch) {
1045				//parsing touch event
1046				var touches = e.originalEvent.touches;
1047				if(touches && touches.length > 0) {
1048					point = touches[0];
1049					if(touches.length > 1) {
1050						self._multipleTouches = true;
1051					}
1052				}					
1053				else {	
1054					return;						
1055				}
1056			} else {
1057				e.preventDefault();				
1058				point = e;
1059				if(self.msEnabled) point = point.originalEvent;		
1060			}
1061
1062			self._isDragging = true;
1063			self._doc.on(self._moveEvent, function(e) { self._onDragMove(e, isThumbs); })
1064						.on(self._upEvent, function(e) { self._onDragRelease(e, isThumbs); });
1065			
1066			self._currMoveAxis = '';
1067			self._hasMoved = false;
1068			self._pageX = point.pageX;
1069			self._pageY = point.pageY;
1070			self._startPagePos = self._accelerationPos = (!isThumbs ? self._slidesHorizontal : self._thumbsHorizontal) ? point.pageX : point.pageY;
1071			
1072			self._horDir = 0;
1073			self._verDir = 0;
1074
1075
1076			self._currRenderPosition = !isThumbs ? self._sPosition : self._thumbsPosition;
1077
1078			self._startTime = new Date().getTime();
1079			if(isTouch) {
1080				self._sliderOverflow.on(self._cancelEvent, function(e) { self._onDragRelease(e, isThumbs); });	
1081			}
1082		},
1083		_renderMovement:function(point, isThumbs) {
1084			var self = this;
1085			if(self._checkedAxis) {
1086
1087				var timeStamp = self._renderMoveTime,
1088					deltaX = point.pageX - self._pageX,
1089					deltaY = point.pageY - self._pageY,
1090					newX = self._currRenderPosition + deltaX,
1091					newY = self._currRenderPosition + deltaY,
1092					isHorizontal = (!isThumbs ? self._slidesHorizontal : self._thumbsHorizontal),
1093					newPos = isHorizontal ? newX : newY,
1094					mAxis = self._currMoveAxis;
1095
1096				self._hasMoved = true;
1097				self._pageX = point.pageX;
1098				self._pageY = point.pageY;
1099
1100				if(mAxis === 'x' && deltaX !== 0) {
1101					self._horDir = deltaX > 0 ? 1 : -1;
1102				} else if(mAxis === 'y' && deltaY !== 0) {
1103					self._verDir = deltaY > 0 ? 1 : -1;
1104				}
1105

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

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

1499
1500					if(item && item.images && item.isLoaded) {
1501						item.isRendered = false;
1502						self._resizeImage(item);
1503					} 
1504				}
1505				if(self._cloneHolders) {
1506					for(i = 0; i < self._cloneHolders.length; i++) {
1507						item = self._cloneHolders[i];
1508						item.holder.css(self._reorderProp, (item.id + self._idOffset) * self._slideSize);
1509					}
1510				}
1511				
1512				self._updateBlocksContent();
1513
1514				if(self._isMove) {
1515					if(self._useCSS3Transitions) {
1516						self._slidesContainer.css(self._vendorPref + 'transition-duration', '0s');
1517					}
1518					self._setPosition( (-self._realId - self._idOffset) * self._slideSize);
1519				}
1520				self.ev.trigger('rsOnUpdateNav');
1521			}
1522			self._sliderOffset = self._sliderOverflow.offset();
1523			self._sliderOffset = self._sliderOffset[self._reorderProp];
1524
1525
1526		},
1527		//setSlidesOrientation: function(orient) {
1528			// TODO
1529			// var self = this,
1530			// 	newHor = Boolean(orient === 'horizontal');
1531			// if(self._slidesHorizontal !== newHor) {
1532			// 	self._setPosition(0);
1533			// 	if(self._isMove) {
1534			// 		for(var i = 0; i < self._slideHolders.length; i++) {
1535			// 			self._slideHolders[i].block.css(self._reorderProp, '');
1536			// 		}
1537			// 	}
1538			// 	self.slider.removeClass(self._slidesHorizontal ? 'rsHor' : 'rsVer').addClass(newHor ? 'rsHor' : 'rsVer');
1539			// 	self._slidesHorizontal = newHor;
1540			// 	self._reorderProp = newHor ? 'left' : 'top';
1541			// 	self.updateSliderSize(true);
1542			// }
1543		//},
1544		/**
1545		 * Adds slide
1546		 * @param  {jQuery object or raw HTML} htmltext 
1547		 * @param  {int} index    (optional) Index where item should be added (last item is removed of not specified)
1548		 */
1549		appendSlide: function(htmltext, index) {
1550			var self = this,
1551				parsedSlide = self._parseNode(htmltext);
1552
1553			if(isNaN(index) || index > self.numSlides) {
1554				index = self.numSlides;
1555			}
1556			self.slides.splice(index, 0, parsedSlide);
1557			self.slidesJQ.splice(index, 0, '<div style="'+ (self._isMove ? 'position:absolute;' : self._opacityCSS ) +'" class="rsSlide"></div>');
1558
1559			if(index < self.currSlideId) {
1560				self.currSlideId++;
1561			}
1562			self.ev.trigger('rsOnAppendSlide', [parsedSlide, index]);
1563			
1564			self._refreshSlides(index);
1565
1566			if(index === self.currSlideId) {
1567				self.ev.trigger('rsAfterSlideChange');
1568			}
1569		},
1570
1571		/**
1572		 * Removes slide
1573		 * @param  {int} Index of item that should be removed
1574		 */
1575		removeSlide: function(index) {
1576			var self = this,
1577				slideToRemove = self.slides[index];
1578
1579			if(slideToRemove) {
1580				if(slideToRemove.holder) {
1581					slideToRemove.holder.remove();
1582				}
1583				if(index < self.currSlideId) {
1584					self.currSlideId--;
1585				}
1586				self.slides.splice(index, 1);
1587				self.slidesJQ.splice(index, 1);
1588
1589				self.ev.trigger('rsOnRemoveSlide', [index]);
1590				self._refreshSlides(index);
1591
1592				if(index === self.currSlideId) {
1593					self.ev.trigger('rsAfterSlideChange');
1594				}
1595			}
1596		},
1597		_refreshSlides: function(refreshIndex) {
1598
1599			// todo: optimize this stuff
1600			var self = this;
1601
1602			var oldNumSlides = self.numSlides;
1603			var numLoops = self._realId <= 0 ? 0 : Math.floor(self._realId / oldNumSlides);
1604
1605			self.numSlides = self.slides.length;
1606			if(self.numSlides === 0) {
1607				self.currSlideId = self._idOffset = self._realId = 0;
1608				self.currSlide = self._oldHolder = null;
1609			} else {
1610				self._realId = numLoops * self.numSlides + self.currSlideId;
1611			}
1612
1613			for(var i = 0; i < self.numSlides; i++) {
1614				self.slides[i].id = i;
1615			}
1616
1617			self.currSlide = self.slides[self.currSlideId];
1618			self._currHolder = self.slidesJQ[self.currSlideId];
1619
1620			if(self.currSlideId >= self.numSlides) {
1621				self.goTo(self.numSlides - 1);
1622			} else if(self.currSlideId < 0) {
1623				self.goTo(0);
1624			}
1625
1626			self._refreshNumPreloadImages();
1627
1628			if(self._isMove && self._loop) {
1629				self._slidesContainer.css((self._vendorPref + self._TD), '0ms');
1630			}
1631			if(self._refreshSlidesTimeout) {
1632				clearTimeout(self._refreshSlidesTimeout);
1633			}
1634
1635
1636			self._refreshSlidesTimeout = setTimeout(function() {
1637				if(self._isMove) {
1638					self._setPosition( (-self._realId - self._idOffset) * self._slideSize);	
1639				}
1640				self._updateBlocksContent();
1641				if(!self._isMove) {
1642					self._currHolder.css({
1643						display: 'block',
1644						opacity: 1
1645					});
1646				}
1647				
1648			}, 14);
1649			self.ev.trigger('rsOnUpdateNav');
1650		},
1651		_setGrabCursor:function() {	
1652			var self = this;
1653			if(self._hasDrag && self._isMove) {
1654				if(self._grabCursor) {
1655					self._sliderOverflow.css('cursor', self._grabCursor);
1656				} else {
1657					self._sliderOverflow.removeClass('grabbing-cursor');
1658					self._sliderOverflow.addClass('grab-cursor');	
1659				}
1660			}
1661		},
1662		_setGrabbingCursor:function() {		
1663			var self = this;
1664			if(self._hasDrag && self._isMove) {
1665				if(self._grabbingCursor) {
1666					self._sliderOverflow.css('cursor', self._grabbingCursor);
1667				} else {
1668					self._sliderOverflow.removeClass('grab-cursor');
1669					self._sliderOverflow.addClass('grabbing-cursor');	
1670				}	
1671			}
1672		},
1673		next: function(notUserAction) {
1674			var self = this;
1675			self._moveTo('next',  self.st.transitionSpeed, true, !notUserAction);
1676		},
1677		prev: function(notUserAction) {
1678			var self = this;
1679			self._moveTo('prev', self.st.transitionSpeed, true, !notUserAction);
1680		},
1681		_moveTo:function(type,  speed, inOutEasing, userAction, fromSwipe) {
1682			var self = this,
1683				newPos,
1684				difference,
1685				i;
1686			
1687			
1688			self.ev.trigger('rsBeforeMove', [type, userAction]);
1689			if(type === 'next') {
1690				newItemId = self.currSlideId+1;
1691			} else if(type === 'prev') {
1692				newItemId = self.currSlideId-1;
1693			} else {
1694				newItemId = type = parseInt(type, 10);
1695			}
1696
1697			if(!self._loop) {
1698				if(newItemId < 0) {
1699					self._doBackAndForthAnim('left', !userAction);
1700					return;
1701				} else if(newItemId >= self.numSlides ) {
1702					self._doBackAndForthAnim('right', !userAction);
1703					return;
1704				}
1705			}
1706			
1707			if(self._isAnimating) {
1708				self._stopAnimation(true);
1709				inOutEasing = false;

1710			}
1711
1712			difference = newItemId - self.currSlideId;
1713
1714
1715
1716			self._prevSlideId = self.currSlideId;
1717			var prevId = self.currSlideId;
1718			var id = self.currSlideId + difference;
1719			var realId = self._realId;
1720			var temp;
1721			var delayed;
1722			if(self._loop) {
1723				id = self._updateBlocksContent(false, id);
1724				realId += difference;
1725			} else {
1726				realId = id;
1727			}
1728			self._newSlideId = id;
1729
1730			self._oldHolder = self.slidesJQ[self.currSlideId];
1731
1732			
1733			self._realId = realId;
1734			self.currSlideId = self._newSlideId;
1735
1736			self.currSlide = self.slides[self.currSlideId];
1737			self._currHolder = self.slidesJQ[self.currSlideId];
1738
1739			
1740			var checkDist = self.st.slidesDiff;
1741			var next = Boolean(difference > 0);
1742			var absDiff = Math.abs(difference);
1743			var g1 = Math.floor( prevId / self._numPreloadImages);
1744			var g2 = Math.floor( ( prevId + (next ? checkDist : -checkDist  ) ) / self._numPreloadImages);
1745			var biggest = next ? Math.max(g1,g2) : Math.min(g1,g2);
1746			var biggestId = biggest * self._numPreloadImages +  ( next ? (self._numPreloadImages - 1) : 0 );
1747			if(biggestId > self.numSlides - 1) {
1748				biggestId = self.numSlides - 1;
1749			} else if(biggestId < 0) {
1750				biggestId = 0;
1751			}
1752			var toLast =  next ? (biggestId - prevId) :  (prevId - biggestId);
1753			if(toLast > self._numPreloadImages) {
1754				toLast = self._numPreloadImages;
1755			}
1756			if(absDiff > toLast + checkDist) {
1757				self._idOffset +=  ( absDiff - (toLast + checkDist) ) * ( next ? -1 : 1 );
1758				speed = speed * 1.4;
1759				for(i = 0; i < self.numSlides; i++) {
1760					self.slides[i].positionSet = false;
1761				}
1762			}
1763			self._currAnimSpeed = speed;
1764
1765			self._updateBlocksContent(true);
1766			if(!fromSwipe) {
1767				delayed = true;
1768			}
1769
1770
1771			newPos = (-realId - self._idOffset) * self._slideSize;
1772
1773			
1774
1775			if(delayed) {
1776				setTimeout(function() {
1777					self._isWorking = false;
1778					self._animateTo(newPos, type, false, inOutEasing);
1779					self.ev.trigger('rsOnUpdateNav');
1780				}, 0);
1781			} else {
1782				self._animateTo(newPos, type, false, inOutEasing);
1783				self.ev.trigger('rsOnUpdateNav');
1784			}
1785			
1786			
1787			function isSetToCurrent(testId) {
1788				if(testId < 0) {
1789					testId = self.numSlides + testId;
1790				} else if(testId > self.numSlides - 1) {
1791					testId = testId - self.numSlides;
1792				}
1793				if(testId !== self.currSlideId) {
1794					return false;
1795				}
1796				return true;
1797			}
1798			
1799		},
1800		_updateArrowsNav: function() {
1801			var self = this,
1802				arrDisClass = 'rsArrowDisabled';
1803			if(self.st.arrowsNav) {
1804				if(self.numSlides <= 1) {
1805					self._arrowLeft.css('display', 'none');
1806					self._arrowRight.css('display', 'none');
1807					return;
1808				} else {
1809					self._arrowLeft.css('display', 'block');
1810					self._arrowRight.css('display', 'block');
1811				}
1812				if(!self._loop && !self.st.loopRewind) {
1813					if(self.currSlideId === 0) {
1814						self._arrowLeft.addClass(arrDisClass);
1815					} else {
1816						self._arrowLeft.removeClass(arrDisClass);
1817					}
1818					if(self.currSlideId === self.numSlides - 1) {
1819						self._arrowRight.addClass(arrDisClass);
1820					} else {
1821						self._arrowRight.removeClass(arrDisClass);
1822					}
1823				}
1824			}
1825		},
1826		_animateTo:function(pos, dir,  loadAll, inOutEasing, customComplete) {
1827			var self = this,
1828				moveProp,
1829				oldBlock,
1830				animBlock;
1831
1832			var animObj = {};
1833			if(isNaN(self._currAnimSpeed)) {
1834				self._currAnimSpeed = 400;
1835			} 
1836			
1837
1838
1839			self._sPosition = self._currRenderPosition = pos;
1840
1841			self.ev.trigger('rsBeforeAnimStart');
1842
1843			if(!self._useCSS3Transitions) {
1844				if(self._isMove) {
1845					animObj[self._slidesHorizontal ? self._xProp : self._yProp] = pos + 'px';
1846
1847
1848					self._slidesContainer.animate(animObj, self._currAnimSpeed, /*'easeOutQuart'*/ inOutEasing ? self.st.easeInOut : self.st.easeOut);
1849				} else {
1850					oldBlock = self._oldHolder;
1851					animBlock = self._currHolder;					
1852
1853					animBlock.stop(true, true).css({
1854						opacity: 0,
1855						display: 'block',
1856						zIndex: self._fadeZIndex
1857					});
1858					self._currAnimSpeed = self.st.transitionSpeed;
1859					animBlock.animate({opacity: 1}, self._currAnimSpeed, self.st.easeInOut);
1860
1861					
1862					clearTimeouts();
1863					if(oldBlock) {
1864	 					oldBlock.data('rsTimeout', setTimeout(function() {
1865							oldBlock.stop(true, true).css({
1866								opacity: 0,
1867								display: 'none',
1868								zIndex: 0
1869							});
1870						}, self._currAnimSpeed + 60) );
1871					}
1872				}
1873				
1874			} else {
1875				if(self._isMove) {
1876					
1877					
1878
1879						self._currAnimSpeed = parseInt(self._currAnimSpeed);
1880						var td = self._vendorPref + self._TD;
1881						var ttf = self._vendorPref + self._TTF;
1882
1883						animObj[td] = self._currAnimSpeed+'ms';
1884						animObj[ttf] = inOutEasing ? $.rsCSS3Easing[self.st.easeInOut] : $.rsCSS3Easing[self.st.easeOut];
1885						
1886						self._slidesContainer.css(animObj);
1887					if(inOutEasing || !self.hasTouch) {
1888						setTimeout(function() {
1889							self._setPosition(pos);
1890						}, 5);
1891					} else {
1892						self._setPosition(pos);
1893					} 
1894					
1895					
1896
1897				} else {
1898					//self._currAnimSpeed = 10
1899					self._currAnimSpeed = self.st.transitionSpeed;
1900					oldBlock = self._oldHolder;
1901					animBlock = self._currHolder;		
1902					if(animBlock.data('rsTimeout')) {
1903						animBlock.css('opacity', 0);
1904					}
1905					clearTimeouts();
1906					if(oldBlock) {
1907						//if(oldBlock)
1908						oldBlock.data('rsTimeout', setTimeout(function() {
1909							animObj[self._vendorPref + self._TD] = '0ms';
1910							animObj.zIndex = 0;
1911							animObj.display = 'none';
1912							oldBlock.data('rsTimeout', '');
1913							oldBlock.css(animObj);
1914							setTimeout(function() {
1915								oldBlock.css('opacity', 0);
1916							}, 16);
1917						}, self._currAnimSpeed + 60) );
1918					}
1919
1920					animObj.display = 'block';
1921					animObj.zIndex = self._fadeZIndex;
1922					animObj.opacity = 0;
1923					animObj[self._vendorPref + self._TD] = '0ms';
1924					animObj[self._vendorPref + self._TTF] = $.rsCSS3Easing[self.st.easeInOut];
1925					animBlock.css(animObj);
1926					animBlock.data('rsTimeout', setTimeout(function() {
1927						//animBlock.css('opacity', 0);
1928						animBlock.css(self._vendorPref + self._TD,  self._currAnimSpeed+'ms');
1929
1930						//oldBlock.css(self._vendorPref + self._TD,  '0ms');
1931						animBlock.data('rsTimeout', setTimeout(function() {
1932							animBlock.css('opacity', 1);
1933							animBlock.data('rsTimeout', '');
1934						}, 20) );
1935					}, 20) );
1936				}
1937			}
1938			self._isAnimating = true;
1939			if(self.loadingTimeout) {
1940				clearTimeout(self.loadingTimeout);
1941			}
1942			if(customComplete) {
1943				self.loadingTimeout = setTimeout(function() {
1944					self.loadingTimeout = null;
1945					customComplete.call();
1946
1947				}, self._currAnimSpeed + 60);
1948			} else {
1949				self.loadingTimeout = setTimeout(function() {
1950					self.loadingTimeout = null;
1951					self._animationComplete(dir);
1952				}, self._currAnimSpeed + 60);
1953			}
1954
1955			function clearTimeouts() {
1956				var t;
1957				if(oldBlock) {
1958					t = oldBlock.data('rsTimeout');
1959					if(t) {
1960						if(oldBlock !== animBlock) {
1961							oldBlock.css({
1962									opacity: 0,
1963									display: 'none',
1964									zIndex: 0
1965								});
1966						}
1967						clearTimeout(t);
1968						oldBlock.data('rsTimeout', '');
1969					}
1970				}
1971				
1972				t = animBlock.data('rsTimeout');
1973				if(t) {
1974					clearTimeout(t);
1975					animBlock.data('rsTimeout', '');
1976				}
1977			}
1978		},
1979		_stopAnimation: function(noCSS3) {
1980			var self = this;
1981			self._isAnimating = false;

1982			clearTimeout(self.loadingTimeout);
1983			if(self._isMove) {
1984
1985				if(!self._useCSS3Transitions) {
1986					self._slidesContainer.stop(true);
1987					self._sPosition = parseInt(self._slidesContainer.css(self._xProp), 10);
1988				} else if (!noCSS3) {
1989					var oldPos = self._sPosition;
1990					var newPos =  self._currRenderPosition = self._getTransformProp();
1991					self._slidesContainer.css((self._vendorPref + self._TD), '0ms');
1992					if(oldPos !==newPos) {
1993						self._setPosition(newPos);
1994					}
1995				}
1996			} else {
1997				// kung fu
1998				if(self._fadeZIndex > 20) {
1999					self._fadeZIndex = 10;
2000				} else {
2001					self._fadeZIndex++;
2002				}
2003			}
2004			
2005			
2006		},
2007		// Thanks to @benpbarnett
2008		_getTransformProp:function(){
2009			var self = this,
2010				transform = window.getComputedStyle(self._slidesContainer.get(0), null).getPropertyValue(self._vendorPref + 'transform'),			
2011				explodedMatrix = transform.replace(/^matrix\(/i, '').split(/, |\)$/g),
2012				isMatrix3d = (explodedMatrix[0].indexOf('matrix3d') === 0);
2013			return parseInt(explodedMatrix[(self._slidesHorizontal ? (isMatrix3d ? 12 : 4) : (isMatrix3d ? 13 : 5) )], 10);
2014		},
2015		_getCSS3Prop: function(pos, hor) {
2016			var self = this;
2017			return self._useCSS3Transitions ? self._tPref1 + ( hor ? (pos + self._tPref2 + 0) : (0 + self._tPref2 + pos) ) + self._tPref3 : pos;
2018		},
2019		_animationComplete: function(dir) {
2020			var self = this;
2021			if(!self._isMove) {
2022				self._currHolder.css('z-index', 0);
2023				self._fadeZIndex = 10;
2024			}
2025			self._isAnimating = false;
2026			
2027			self.staticSlideId = self.currSlideId;
2028			self._updateBlocksContent();
2029
2030
2031			self._slidesMoved = false;
2032			
2033			self.ev.trigger('rsAfterSlideChange');
2034		},
2035		_doBackAndForthAnim:function(type, userAction) {
2036			var self = this,
2037				newPos = (-self._realId - self._idOffset) * self._slideSize;
2038
2039			if(self.numSlides === 0 || self._isAnimating) {
2040				return;
2041			} 
2042			if(self.st.loopRewind) {
2043				self.goTo(type === 'left' ? self.numSlides - 1 : 0, userAction);
2044				return;
2045			}
2046
2047			if(self._isMove) {
2048				self._currAnimSpeed = 200;
2049
2050				function allAnimComplete() {
2051					self._isAnimating = false;
2052				}
2053				function firstAnimComplete() {
2054					self._isAnimating = false;
2055					self._animateTo(newPos, '', false, true, allAnimComplete);
2056				}
2057				self._animateTo(newPos + (type === 'left' ? 30 : -30),'', false, true, firstAnimComplete);
2058			}
2059			
2060		},
2061		_resizeImage:function(slideObject, useClone) {
2062

2063			var isRoot = true;
2064			if(slideObject.isRendered) {
2065				return;
2066			}
2067			var img = slideObject.content;
2068			var classToFind = 'rsMainSlideImage';
2069			var isVideo;
2070			var self = this,
2071				imgAlignCenter = self.st.imageAlignCenter,
2072				imgScaleMode = self.st.imageScaleMode,
2073				tempEl;
2074
2075			if(slideObject.videoURL) {
2076				classToFind = 'rsVideoContainer';
2077				if(imgScaleMode !== 'fill') {
2078					isVideo = true;
2079				} else {
2080					tempEl = img;
2081					if(!tempEl.hasClass(classToFind)) {
2082						tempEl = tempEl.find('.'+classToFind);
2083					}
2084					tempEl.css({width:'100%',height: '100%'});
2085					classToFind = 'rsMainSlideImage';
2086				}
2087			}
2088			if(!img.hasClass(classToFind)) {
2089				isRoot = false;
2090				img = img.find('.'+classToFind);
2091			}
2092			if(!img) {
2093				return;
2094			}
2095
2096			var baseImageWidth = slideObject.iW,
2097				baseImageHeight = slideObject.iH;
2098
2099			slideObject.isRendered = true;
2100			if(imgScaleMode === 'none' && !imgAlignCenter) {
2101				return;
2102			}
2103			if(imgScaleMode !== 'fill') {
2104				bMargin = self._imagePadding;
2105			} else {
2106				bMargin = 0;
2107			}
2108			//var block = img.parent('.block-inside').css('margin', bMargin);
2109			var containerWidth = self._wrapWidth - bMargin * 2,
2110				containerHeight = self._wrapHeight - bMargin * 2,
2111				hRatio,
2112				vRatio,
2113				ratio,
2114				nWidth,
2115				nHeight,
2116				cssObj = {};
2117
2118			if(imgScaleMode === 'fit-if-smaller') {
2119				if(baseImageWidth > containerWidth || baseImageHeight > containerHeight) {
2120					imgScaleMode = 'fit';
2121				}
2122			}
2123			if(imgScaleMode === 'fill' || imgScaleMode === 'fit') {		
2124				hRatio = containerWidth / baseImageWidth;
2125				vRatio = containerHeight / baseImageHeight;
2126
2127				if (imgScaleMode  == "fill") {
2128					ratio = hRatio > vRatio ? hRatio : vRatio;                    			
2129				} else if (imgScaleMode  == "fit") {
2130					ratio = hRatio < vRatio ? hRatio : vRatio;             		   	
2131				} else {
2132					ratio = 1;
2133				}
2134
2135				nWidth = Math.ceil(baseImageWidth * ratio, 10);
2136				nHeight = Math.ceil(baseImageHeight * ratio, 10);
2137			} else {								
2138				nWidth = baseImageWidth;
2139				nHeight = baseImageHeight;		
2140			}
2141			if(imgScaleMode !== 'none') {
2142				cssObj.width = nWidth;
2143				cssObj.height = nHeight;
2144				if(isVideo) {
2145					img.find('.rsImg').css({width: '100%', height:'100%'});
2146				}
2147			}
2148			if (imgAlignCenter) {     
2149				cssObj.marginLeft = Math.floor((containerWidth - nWidth) / 2) +  bMargin;
2150				cssObj.marginTop = Math.floor((containerHeight - nHeight) / 2) +  bMargin;
2151			}
2152			img.css(cssObj);
2153		}
2154	}; /* RoyalSlider core prototype end */
2155	$.rsProto = RoyalSlider.prototype;
2156
2157	$.fn.royalSlider = function(options) {    	
2158		var args = arguments;
2159		return this.each(function(){
2160			var self = $(this);
2161			if (typeof options === "object" ||  !options) {
2162				if( !self.data('royalSlider') ) {
2163					self.data('royalSlider', new RoyalSlider(self, options));
2164				}
2165			} else {
2166				var royalSlider = self.data('royalSlider');
2167				if (royalSlider && royalSlider[options]) {
2168					return royalSlider[options].apply(royalSlider, Array.prototype.slice.call(args, 1));
2169				}
2170			}
2171		});
2172	};
2173
2174	$.fn.royalSlider.defaults = {    
2175		slidesSpacing: 8,
2176		startSlideId: 0,
2177		loop: false,
2178		loopRewind: false,
2179		numImagesToPreload: 4,
2180		fadeinLoadedSlide: true,
2181		slidesOrientation: 'horizontal', 
2182		transitionType: 'move', 
2183		transitionSpeed: 600,
2184		controlNavigation: 'bullets',
2185		controlsInside: true, 
2186		arrowsNav: true,
2187		arrowsNavAutoHide: true,
2188		navigateByClick: true,
2189		randomizeSlides: false,
2190		sliderDrag: true, 
2191		sliderTouch: true,
2192		keyboardNavEnabled: false,
2193		fadeInAfterLoaded: true,
2194
2195		allowCSS3: true,
2196		allowCSS3OnWebkit: true,
2197
2198		
2199		addActiveClass: false,
2200		autoHeight: false,
2201
2202		easeOut: 'easeOutSine',
2203		easeInOut: 'easeInOutSine',
2204
2205		minSlideOffset: 10,
2206
2207		imageScaleMode:"fit-if-smaller",                 
2208		imageAlignCenter:true,				
2209		imageScalePadding: 4,
2210		usePreloader: true,
2211
2212		autoScaleSlider: false,               
2213   					
2214   		autoScaleSliderWidth: 800,       
2215   		autoScaleSliderHeight: 400,   
2216
2217   		autoScaleHeight: true,	    
2218
2219   		arrowsNavHideOnTouch: false,
2220   		globalCaption: false,
2221
2222   		slidesDiff: 2,
2223   		
2224   		disableResponsiveness: false // !disable responsiveness option
2225	}; /* default options end */
2226
2227	$.rsCSS3Easing = {
2228		easeOutSine: 'cubic-bezier(0.390, 0.575, 0.565, 1.000)',
2229		easeInOutSine: 'cubic-bezier(0.445, 0.050, 0.550, 0.950)'
2230	};
2231
2232	$.extend(jQuery.easing, {
2233		easeInOutSine: function (x, t, b, c, d) {

2234			return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
2235		},
2236		easeOutSine: function (x, t, b, c, d) {
2237			return c * Math.sin(t/d * (Math.PI/2)) + b;
2238		},
2239		easeOutCubic: function (x, t, b, c, d) {
2240			return c*((t=t/d-1)*t*t + 1) + b;
2241		}
2242	});
2243
2244	/****************************************************************************************************************/
2245	/**
2246	 *
2247	 * RoyalSlider fullscreen module
2248	 * @version 1.0.5:
2249	 *
2250	 * 1.0.1:
2251	 * - Added rsEnterFullscreen and rsExitFullscreen events
2252	 *
2253	 * 1.0.2
2254	 * - Added window scroll detection
2255	 *
2256	 * 1.0.3
2257	 * - Fullscreen button now is added to _controlsContainer element
2258	 *
2259	 * 1.0.4
2260	 * - Fixed issue that could cause small image be loaded in fullscreen
2261	 *
2262	 * 1.0.5
2263	 * - Fix "false" native fullscreen on Android
2264	 * 
2265	 */
2266	$.extend($.rsProto, {
2267		_initFullscreen: function() {
2268			var self = this;
2269
2270			self._fullscreenDefaults = {
2271				enabled: false,
2272				keyboardNav: true,
2273				buttonFS: true,
2274				nativeFS: false,
2275				doubleTap: true
2276			};
2277			self.st.fullscreen = $.extend({}, self._fullscreenDefaults, self.st.fullscreen);
2278
2279			if(self.st.fullscreen.enabled) {
2280				self.ev.one('rsBeforeSizeSet', function() {
2281					self._setupFullscreen();
2282				});
2283			}
2284		},
2285		_setupFullscreen: function() {
2286			var self = this;
2287			self._fsKeyboard = (!self.st.keyboardNavEnabled && self.st.fullscreen.keyboardNav);
2288
2289			if(self.st.fullscreen.nativeFS) {
2290				// Thanks to John Dyer http://j.hn/
2291			    self._fullScreenApi = {
2292			            supportsFullScreen: false,
2293			            isFullScreen: function() { return false; },
2294			            requestFullScreen: function() {},
2295			            cancelFullScreen: function() {},
2296			            fullScreenEventName: '',
2297			            prefix: ''
2298			        };
2299			    var browserPrefixes = 'webkit moz o ms khtml'.split(' ');
2300			    // check for native support
2301			    if(!self.isAndroid) {
2302			    
2303				    if (typeof document.cancelFullScreen != 'undefined') {
2304				         self._fullScreenApi.supportsFullScreen = true;
2305				    } else {
2306				        // check for fullscreen support by vendor prefix
2307				        for (var i = 0; i < browserPrefixes.length; i++ ) {
2308				             self._fullScreenApi.prefix = browserPrefixes[i];
2309				 
2310				            if (typeof document[ self._fullScreenApi.prefix + 'CancelFullScreen' ] != 'undefined' ) {
2311				                 self._fullScreenApi.supportsFullScreen = true;
2312				 
2313				                break;
2314				            }
2315				        }
2316				    }
2317
2318			    }
2319			 
2320			    // update methods to do something useful
2321			    if ( self._fullScreenApi.supportsFullScreen) {
2322			    	self.nativeFS = true;
2323			         self._fullScreenApi.fullScreenEventName =  self._fullScreenApi.prefix + 'fullscreenchange' + self.ns;
2324			 	
2325			         self._fullScreenApi.isFullScreen = function() {
2326			            switch (this.prefix) {
2327			                case '':
2328			                    return document.fullScreen;
2329			                case 'webkit':
2330			                    return document.webkitIsFullScreen;
2331			                default:
2332			                    return document[this.prefix + 'FullScreen'];
2333			            }
2334			        };
2335			         self._fullScreenApi.requestFullScreen = function(el) {
2336			            return (this.prefix === '') ? el.requestFullScreen() : el[this.prefix + 'RequestFullScreen']();
2337			        };
2338			         self._fullScreenApi.cancelFullScreen = function(el) {
2339			            return (this.prefix === '') ? document.cancelFullScreen() : document[this.prefix + 'CancelFullScreen']();
2340			        };
2341			    } else {
2342			    	self._fullScreenApi = false;
2343			    }
2344			}
2345
2346
2347			if(self.st.fullscreen.buttonFS) {
2348				self._fsBtn = $('<div class="rsFullscreenBtn"><div class="rsFullscreenIcn"></div></div>')
2349					.appendTo(self._controlsContainer)
2350					.on('click.rs', function() {
2351						if(self.isFullscreen) {
2352							self.exitFullscreen();
2353						} else {
2354
2355							self.enterFullscreen();
2356						}
2357					});
2358			}
2359		},
2360		enterFullscreen: function(preventNative) {
2361			var self = this;
2362			if( self._fullScreenApi ) {
2363				if(!preventNative) {
2364					self._doc.on( self._fullScreenApi.fullScreenEventName, function(e) {
2365						if(!self._fullScreenApi.isFullScreen()) {
2366							self.exitFullscreen(true);
2367						} else {
2368							self.enterFullscreen(true);
2369						}
2370					});
2371					self._fullScreenApi.requestFullScreen($('html')[0]);
2372					return;
2373				} else {
2374					self._fullScreenApi.requestFullScreen($('html')[0]);
2375				}
2376			}
2377
2378			if(self._isFullscreenUpdating) {
2379				return;
2380			}
2381			self._isFullscreenUpdating = true;
2382
2383			self._doc.on('keyup' + self.ns + 'fullscreen', function(e) {
2384				if(e.keyCode === 27) {
2385					self.exitFullscreen();
2386				}
2387			});
2388			if(self._fsKeyboard) {
2389				self._bindKeyboardNav();
2390			}
2391
2392			var win = $(window);
2393			self._fsScrollTopOnEnter = win.scrollTop();
2394			self._fsScrollLeftOnEnter = win.scrollLeft();
2395
2396			self._htmlStyle = $('html').attr('style');
2397			self._bodyStyle = $('body').attr('style');
2398			self._sliderStyle = self.slider.attr('style');
2399
2400			$('body, html').css({
2401				overflow: 'hidden',
2402				height: '100%',
2403				width: '100%',
2404				margin: '0',
2405				padding: '0'
2406			});
2407
2408			self.slider.addClass('rsFullscreen');
2409			
2410		
2411			var item,
2412				i;
2413			for(i = 0; i < self.numSlides; i++) {
2414				item = self.slides[i];
2415				
2416				item.isRendered = false;

2417				if(item.bigImage) {
2418					item.isBig = true;
2419					item.isMedLoaded = item.isLoaded;
2420					item.isMedLoading = item.isLoading;
2421					item.medImage = item.image;
2422					item.medIW = item.iW;
2423					item.medIH = item.iH;
2424					item.slideId = -99;
2425
2426					if(item.bigImage !== item.medImage) {
2427						item.sizeType = 'big';
2428					}
2429
2430					item.isLoaded = item.isBigLoaded;
2431					item.isLoading = false;
2432					item.image = item.bigImage;
2433					item.images[0] = item.bigImage;
2434					item.iW = item.bigIW;
2435					item.iH = item.bigIH;
2436
2437					item.isAppended = item.contentAdded = false;
2438					self._updateItemSrc(item);
2439				}
2440				
2441			}
2442
2443			
2444			self.isFullscreen = true;
2445			
2446			self._isFullscreenUpdating = false;
2447			self.updateSliderSize();
2448			self.ev.trigger('rsEnterFullscreen');
2449			
2450		},
2451		exitFullscreen: function(preventNative) {
2452			var self = this;
2453
2454			if( self._fullScreenApi ) {
2455				if(!preventNative) {
2456					self._fullScreenApi.cancelFullScreen($('html')[0]);
2457					return;
2458				}
2459				self._doc.off( self._fullScreenApi.fullScreenEventName );
2460			}
2461			if(self._isFullscreenUpdating) {
2462				return;
2463			}
2464			self._isFullscreenUpdating = true;
2465
2466			self._doc.off('keyup'  + self.ns + 'fullscreen');
2467			if(self._fsKeyboard) {
2468				self._doc.off('keydown' + self.ns);
2469			}
2470
2471			$('html').attr('style', self._htmlStyle || '');
2472			$('body').attr('style', self._bodyStyle || '');
2473			
2474
2475			
2476			var item,
2477				i;
2478			for(i = 0; i < self.numSlides; i++) {
2479				item = self.slides[i];
2480				
2481				
2482				item.isRendered = false;
2483				if(item.bigImage) {
2484					item.isBig = false;
2485					item.slideId = -99;
2486					item.isBigLoaded = item.isLoaded;
2487					item.isBigLoading = item.isLoading;
2488					item.bigImage = item.image;
2489					item.bigIW = item.iW;
2490					item.bigIH = item.iH;
2491					item.isLoaded = item.isMedLoaded;
2492					item.isLoading = false;
2493					item.image = item.medImage;
2494					item.images[0] = item.medImage;
2495					item.iW = item.medIW;
2496					item.iH = item.medIH;
2497
2498					item.isAppended = item.contentAdded = false;
2499
2500					self._updateItemSrc(item, true);
2501					
2502					
2503					if(item.bigImage !== item.medImage) {
2504						item.sizeType = 'med';
2505					}
2506				}
2507			}
2508			
2509			self.isFullscreen = false;
2510
2511			var win = $(window);
2512			win.scrollTop( self._fsScrollTopOnEnter );
2513			win.scrollLeft( self._fsScrollLeftOnEnter );
2514			
2515			self._isFullscreenUpdating = false;
2516			self.slider.removeClass('rsFullscreen');
2517
2518			self.updateSliderSize();
2519			// fix overflow bug
2520			setTimeout(function() {
2521				self.updateSliderSize();
2522			},1);
2523			self.ev.trigger('rsExitFullscreen');
2524		},
2525		_updateItemSrc: function(item, exit) {
2526			var newHTML = (!item.isLoaded && !item.isLoading) ? '<a class="rsImg rsMainSlideImage" href="'+item.image+'"></a>' : '<img class="rsImg rsMainSlideImage" src="'+item.image+'"/>';
2527			
2528			if(item.content.hasClass('rsImg')) {
2529				item.content = $(newHTML);
2530			} else {
2531				item.content.find('.rsImg').eq(0).replaceWith(newHTML);
2532			}
2533			if(!item.isLoaded && !item.isLoading && item.holder) {
2534				item.holder.html(item.content);
2535			}
2536		}
2537	});
2538	$.rsModules.fullscreen = $.rsProto._initFullscreen;
2539
2540	/****************************************************************************************************************/
2541
2542		/**
2543	 *
2544	 * RoyalSlider bullets module
2545	 * @version 1.0.1:
2546	 *
2547	 * 1.0.1
2548	 * - Minor optimizations
2549	 * 
2550	 */ 
2551	$.extend($.rsProto, {
2552		_initBullets: function() {
2553			var self = this;
2554			if(self.st.controlNavigation === 'bullets') {
2555				var itemHTML = '<div class="rsNavItem rsBullet"><span></span></div>';
2556				self.ev.one('rsAfterPropsSetup', function() {
2557
2558					self._controlNavEnabled = true;
2559					self.slider.addClass('rsWithBullets');
2560					var out = '<div class="rsNav rsBullets">';
2561					for(var i = 0; i < self.numSlides; i++) {
2562						out += itemHTML;
2563					}
2564					self._controlNav = out = $(out + '</div>');
2565					self._controlNavItems = out.appendTo(self.slider).children();
2566
2567					self._controlNav.on('click.rs','.rsNavItem',function(e) {
2568						if(!self._thumbsDrag ) {
2569							self.goTo( $(this).index() );
2570						}
2571					});
2572				});
2573
2574				self.ev.on('rsOnAppendSlide', function(e, parsedSlide, index) {
2575					if(index >= self.numSlides) {
2576						self._controlNav.append(itemHTML);
2577					} else {
2578						self._controlNavItems.eq(index).before(itemHTML);
2579					}
2580					self._controlNavItems = self._controlNav.children();
2581				});
2582				self.ev.on('rsOnRemoveSlide', function(e, index) {
2583					var itemToRemove = self._controlNavItems.eq(index);
2584					if(itemToRemove && itemToRemove.length) {
2585						itemToRemove.remove();
2586						self._controlNavItems = self._controlNav.children();
2587					}
2588					
2589				});	
2590
2591				self.ev.on('rsOnUpdateNav', function() {
2592					var id = self.currSlideId,
2593						currItem,
2594						prevItem;
2595					if(self._prevNavItem) {
2596						self._prevNavItem.removeClass('rsNavSelected');
2597					}
2598					currItem = self._controlNavItems.eq(id);
2599
2600					currItem.addClass('rsNavSelected');
2601					self._prevNavItem = currItem;
2602				});
2603			}
2604		}
2605	});
2606	$.rsModules.bullets = $.rsProto._initBullets;
2607
2608	/****************************************************************************************************************/
2609	/**
2610	 *
2611	 * RoyalSlider auto height module
2612	 * @version 1.0.2:
2613	 *
2614	 * 1.0.2
2615	 * - Changed "on" to "one" in afterInit event listener
2616	 * - Removed id="clear"
2617	 */ 
2618	$.extend($.rsProto, {
2619		_initAutoHeight: function() {
2620			var self = this;
2621			if(self.st.autoHeight) {
2622				var holder,
2623					tH,
2624					currSlide,
2625					currHeight,
2626					updHeight = function(animate) {
2627						currSlide = self.slides[self.currSlideId];
2628						holder = currSlide.holder;
2629
2630						if(holder) {
2631							tH = holder.height();
2632							if(tH && tH !== currHeight) {
2633								self._wrapHeight = tH;
2634								if(self._useCSS3Transitions || !animate) {
2635									self._sliderOverflow.css('height', tH);
2636								} else {
2637									self._sliderOverflow.stop(true,true).animate({height: tH}, self.st.transitionSpeed);
2638								}
2639							}
2640						}
2641					};
2642
2643				self.ev.on('rsMaybeSizeReady.rsAutoHeight', function(e, slideObject) {
2644					if(currSlide === slideObject) {
2645						updHeight();
2646					}
2647				});
2648
2649				self.ev.on('rsAfterContentSet.rsAutoHeight', function(e, slideObject) {
2650					if(currSlide === slideObject) {
2651						updHeight();
2652					}
2653				});
2654				
2655
2656
2657				self.slider.addClass('rsAutoHeight');
2658				self.ev.one('rsAfterInit', function() {
2659					setTimeout(function() {
2660						updHeight(false);
2661						setTimeout(function() {
2662							self.slider.append('<div style="clear:both; float: none;"></div>');
2663							if(self._useCSS3Transitions) {
2664								self._sliderOverflow.css(self._vendorPref + 'transition', 'height ' + self.st.transitionSpeed + 'ms ease-in-out');
2665							}
2666						}, 16);
2667					}, 16);
2668				});
2669				self.ev.on('rsBeforeAnimStart', function() {
2670					updHeight(true);
2671				});
2672				self.ev.on('rsBeforeSizeSet' , function() {
2673					setTimeout(function() {
2674						updHeight(false);
2675					}, 16);
2676				});
2677			}
2678			
2679		}
2680	});
2681	$.rsModules.autoHeight = $.rsProto._initAutoHeight;
2682
2683	/****************************************************************************************************************/
2684
2685	/**
2686	 *
2687	 * RoyalSlider video module
2688	 * @version 1.1.0:
2689	 *
2690	 * 1.0.3:
2691	 * - Added rsOnDestroyVideoElement event
2692	 *
2693	 * 1.0.4:
2694	 * - Added wmode=transparent to default YouTube video embed code
2695	 *
2696	 * 1.0.5
2697	 * - Fixed bug: HTMl5 YouTube player sometimes keeps playing in ie9 after closing
2698	 *
2699	 * 1.0.6
2700	 * - A bit lightened Vimeo and YouTube regex 
2701	 *
2702	 * 1.0.7
2703	 * - Minor optimizations
2704	 * - Added autoHideCaption option
2705	 *
2706	 * 1.0.9
2707	 * - Fixed error that could appear if updateSliderSize method is called directly after video close
2708	 *
2709	 * 1.1.0
2710	 * - Video is now removed in rsAfterSlideChange event to avoid transition lag