https://www.callaghanprints.com/dfiles/12976/js/jquery.iosslider.js

1
2;(function($) {
3	
4	/* global variables */
5	var scrollbarNumber = 0;
6	var xScrollDistance = 0;
7	var yScrollDistance = 0;
8	var scrollIntervalTime = 10;
9	var scrollbarDistance = 0;
10	var isTouch = 'ontouchstart' in window;
11	var supportsOrientationChange = 'onorientationchange' in window;
12	var isWebkit = false;
13	var has3DTransform = false;
14	var isIe7 = false;
15	var isIe8 = false;
16	var isIe9 = false;
17	var isIe = false;
18	var isGecko = false;
19	var grabOutCursor = 'pointer';
20	var grabInCursor = 'pointer';
21	var onChangeEventLastFired = new Array();
22	var autoSlideTimeouts = new Array();
23	var iosSliders = new Array();
24	var iosSliderSettings = new Array();
25	var isEventCleared = new Array();
26	var slideTimeouts = new Array();
27	var activeChildOffsets = new Array();
28	var activeChildInfOffsets = new Array();
29	var infiniteSliderOffset = new Array();
30	var sliderMin = new Array();
31	var sliderMax = new Array();
32	var sliderAbsMax = new Array();
33	var touchLocks = new Array();
34	
35	/* private functions */
36	var helpers = {
37    
38        showScrollbar: function(settings, scrollbarClass) {
39			
40			if(settings.scrollbarHide) {
41				$('.' + scrollbarClass).css({
42					opacity: settings.scrollbarOpacity,
43					filter: 'alpha(opacity:' + (settings.scrollbarOpacity * 100) + ')'
44				});
45			}
46			
47		},
48		
49		hideScrollbar: function(settings, scrollTimeouts, j, distanceOffsetArray, scrollbarClass, scrollbarWidth, stageWidth, scrollMargin, scrollBorder, sliderNumber) {
50			
51			if(settings.scrollbar && settings.scrollbarHide) {
52					
53				for(var i = j; i < j+25; i++) {
54					
55					scrollTimeouts[scrollTimeouts.length] = helpers.hideScrollbarIntervalTimer(scrollIntervalTime * i, distanceOffsetArray[j], ((j + 24) - i) / 24, scrollbarClass, scrollbarWidth, stageWidth, scrollMargin, scrollBorder, sliderNumber, settings);
56					
57				}
58			
59			}
60			
61		},
62		
63		hideScrollbarInterval: function(newOffset, opacity, scrollbarClass, scrollbarWidth, stageWidth, scrollMargin, scrollBorder, sliderNumber, settings) {
64	
65			scrollbarDistance = (newOffset * -1) / (sliderMax[sliderNumber]) * (stageWidth - scrollMargin - scrollBorder - scrollbarWidth);
66			
67			helpers.setSliderOffset('.' + scrollbarClass, scrollbarDistance);
68			
69			$('.' + scrollbarClass).css({
70				opacity: settings.scrollbarOpacity * opacity,
71				filter: 'alpha(opacity:' + (settings.scrollbarOpacity * opacity * 100) + ')'
72			});
73			
74		},
75		
76		slowScrollHorizontalInterval: function(node, slideNodes, newOffset, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, activeChildOffset, originalOffsets, childrenOffsets, infiniteSliderWidth, numberOfSlides, sliderNumber, centeredSlideOffset, endOffset, settings) {
77
78			if(settings.infiniteSlider) {
79				
80				if(newOffset <= (sliderMax[sliderNumber] * -1)) {
81
82					var scrollerWidth = $(node).width();
83
84					if(newOffset <= (sliderAbsMax[sliderNumber] * -1)) {
85						
86						var sum = originalOffsets[0] * -1;
87						$(slideNodes).each(function(i) {
88							
89							helpers.setSliderOffset($(slideNodes)[i], sum + centeredSlideOffset);
90							if(i < childrenOffsets.length) {
91								childrenOffsets[i] = sum * -1;
92							}
93							sum = sum + $(this).outerWidth(true);
94							
95						});
96						
97						newOffset = newOffset + childrenOffsets[0] * -1;
98						sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
99						sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
100						infiniteSliderOffset[sliderNumber] = 0;
101						
102					} else {
103						
104						var lowSlideNumber = 0;
105						var lowSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
106						$(slideNodes).each(function(i) {
107							
108							if(helpers.getSliderOffset(this, 'x') < lowSlideOffset) {
109								lowSlideOffset = helpers.getSliderOffset(this, 'x');
110								lowSlideNumber = i;
111							}
112							
113						});
114						
115						var tempOffset = sliderMin[sliderNumber] + scrollerWidth;
116						helpers.setSliderOffset($(slideNodes)[lowSlideNumber], tempOffset);
117						
118						sliderMin[sliderNumber] = childrenOffsets[1] * -1 + centeredSlideOffset;
119						sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
120
121						childrenOffsets.splice(0, 1);
122						childrenOffsets.splice(childrenOffsets.length, 0, tempOffset * -1 + centeredSlideOffset);
123
124						infiniteSliderOffset[sliderNumber]++;
125						
126					}
127					
128				}
129				
130				if((newOffset >= (sliderMin[sliderNumber] * -1)) || (newOffset >= 0)) {
131					
132					var scrollerWidth = $(node).width();
133					
134					if(newOffset >= 0) {
135
136						var sum = originalOffsets[0] * -1;
137						$(slideNodes).each(function(i) {
138							
139							helpers.setSliderOffset($(slideNodes)[i], sum + centeredSlideOffset);
140							if(i < childrenOffsets.length) {
141								childrenOffsets[i] = sum * -1;
142							}
143							sum = sum + $(this).outerWidth(true);
144							
145						});
146						
147						newOffset = newOffset - childrenOffsets[0] * -1;
148						sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
149						sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
150						infiniteSliderOffset[sliderNumber] = numberOfSlides;
151						
152						while(((childrenOffsets[0] * -1 - scrollerWidth + centeredSlideOffset) > 0)) {
153
154							var highSlideNumber = 0;
155							var highSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
156							$(slideNodes).each(function(i) {
157								
158								if(helpers.getSliderOffset(this, 'x') > highSlideOffset) {
159									highSlideOffset = helpers.getSliderOffset(this, 'x');
160									highSlideNumber = i;
161								}
162								
163							});
164
165							var tempOffset = sliderMin[sliderNumber] - $(slideNodes[highSlideNumber]).outerWidth(true);
166							helpers.setSliderOffset($(slideNodes)[highSlideNumber], tempOffset);
167							
168							childrenOffsets.splice(0, 0, tempOffset * -1 + centeredSlideOffset);
169							childrenOffsets.splice(childrenOffsets.length-1, 1);
170
171							sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
172							sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
173
174							infiniteSliderOffset[sliderNumber]--;
175							activeChildOffsets[sliderNumber]++;
176							
177						}
178
179					} 
180					
181					if(newOffset < 0) {
182					
183						var highSlideNumber = 0;
184						var highSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
185						$(slideNodes).each(function(i) {
186							
187							if(helpers.getSliderOffset(this, 'x') > highSlideOffset) {
188								highSlideOffset = helpers.getSliderOffset(this, 'x');
189								highSlideNumber = i;
190							}
191							
192						});						
193					
194						var tempOffset = sliderMin[sliderNumber] - $(slideNodes[highSlideNumber]).outerWidth(true);
195						helpers.setSliderOffset($(slideNodes)[highSlideNumber], tempOffset);
196						
197						childrenOffsets.splice(0, 0, tempOffset * -1 + centeredSlideOffset);
198						childrenOffsets.splice(childrenOffsets.length-1, 1);
199
200						sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
201						sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
202
203						infiniteSliderOffset[sliderNumber]--;
204						
205					}
206				
207				}
208				
209			}
210
211			var slideChanged = false;

212			var newChildOffset = helpers.calcActiveOffset(settings, newOffset, childrenOffsets, stageWidth, infiniteSliderOffset[sliderNumber], numberOfSlides, activeChildOffset, sliderNumber);
213			var tempOffset = (newChildOffset + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
214			
215			if(settings.infiniteSlider) {
216								
217				if(tempOffset != activeChildInfOffsets[sliderNumber]) {
218					slideChanged = true;
219				}
220					
221			} else {
222			
223				if(newChildOffset != activeChildOffsets[sliderNumber]) {
224					slideChanged = true;
225				}
226			
227			}
228			
229			if(slideChanged) {
230				
231				var args = new helpers.args(settings, node, $(node).children(':eq(' + tempOffset + ')'), tempOffset, endOffset, true);
232				$(node).parent().data('args', args);
233				
234				if(settings.onSlideChange != '') {
235				
236					settings.onSlideChange(args);
237				
238				}
239			
240			}
241			
242			activeChildOffsets[sliderNumber] = newChildOffset;
243			activeChildInfOffsets[sliderNumber] = tempOffset;
244			
245			newOffset = Math.floor(newOffset);
246			
247			helpers.setSliderOffset(node, newOffset);
248
249			if(settings.scrollbar) {
250				
251				scrollbarDistance = Math.floor((newOffset * -1 - sliderMin[sliderNumber]) / (sliderMax[sliderNumber] - sliderMin[sliderNumber]) * (scrollbarStageWidth - scrollMargin - scrollbarWidth));
252				var width = scrollbarWidth - scrollBorder;
253				
254				if(newOffset >= (sliderMin[sliderNumber] * -1)) {
255
256					width = scrollbarWidth - scrollBorder - (scrollbarDistance * -1);
257					
258					helpers.setSliderOffset($('.' + scrollbarClass), 0);
259					
260					$('.' + scrollbarClass).css({
261						width: width + 'px'
262					});
263				
264				} else if(newOffset <= ((sliderMax[sliderNumber] * -1) + 1)) {
265					
266					width = scrollbarStageWidth - scrollMargin - scrollBorder - scrollbarDistance;
267					
268					helpers.setSliderOffset($('.' + scrollbarClass), scrollbarDistance);
269					
270					$('.' + scrollbarClass).css({
271						width: width + 'px'
272					});
273					
274				} else {
275					
276					helpers.setSliderOffset($('.' + scrollbarClass), scrollbarDistance);
277					
278					$('.' + scrollbarClass).css({
279						width: width + 'px'
280					});
281				
282				}
283				
284			}
285			
286		},
287		
288		slowScrollHorizontal: function(node, slideNodes, scrollTimeouts, scrollbarClass, xScrollDistance, yScrollDistance, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, currentEventNode, snapOverride, centeredSlideOffset, settings) {
289			
290			var distanceOffsetArray = new Array();
291			var xScrollDistanceArray = new Array();
292			var nodeOffset = helpers.getSliderOffset(node, 'x');
293			var snapDirection = 0;
294			var maxSlideVelocity = 25 / 1024 * stageWidth;
295			var changeSlideFired = false;
296			frictionCoefficient = settings.frictionCoefficient;
297			elasticFrictionCoefficient = settings.elasticFrictionCoefficient;
298			snapFrictionCoefficient = settings.snapFrictionCoefficient;
299				
300			if((xScrollDistance > 5) && settings.snapToChildren && !snapOverride) {
301				snapDirection = 1;
302			} else if((xScrollDistance < -5) && settings.snapToChildren && !snapOverride) {
303				snapDirection = -1;
304			}
305			
306			if(xScrollDistance < (maxSlideVelocity * -1)) {
307				xScrollDistance = maxSlideVelocity * -1;
308			} else if(xScrollDistance > maxSlideVelocity) {
309				xScrollDistance = maxSlideVelocity;
310			}
311			
312			if(!($(node)[0] === $(currentEventNode)[0])) {
313				snapDirection = snapDirection * -1;
314				xScrollDistance = xScrollDistance * -2;
315			}
316			
317			var tempInfiniteSliderOffset = infiniteSliderOffset[sliderNumber];
318			
319			if(settings.infiniteSlider) {
320			
321				var tempSliderMin = sliderMin[sliderNumber];
322				var tempSliderMax = sliderMax[sliderNumber];
323			
324			}
325			var tempChildrenOffsets = new Array();
326			var tempSlideNodeOffsets = new Array();
327
328			for(var i = 0; i < childrenOffsets.length; i++) {
329				
330				tempChildrenOffsets[i] = childrenOffsets[i];
331				
332				if(i < slideNodes.length) {
333					tempSlideNodeOffsets[i] = helpers.getSliderOffset($(slideNodes[i]), 'x');
334				}
335				
336			}
337			
338			while((xScrollDistance > 1) || (xScrollDistance < -1)) {
339				
340				xScrollDistance = xScrollDistance * frictionCoefficient;
341				nodeOffset = nodeOffset + xScrollDistance;
342
343				if(((nodeOffset > (sliderMin[sliderNumber] * -1)) || (nodeOffset < (sliderMax[sliderNumber] * -1))) && !sett

343ings.infiniteSlider) {
344					xScrollDistance = xScrollDistance * elasticFrictionCoefficient;
345					nodeOffset = nodeOffset + xScrollDistance;
346				}
347				
348				if(settings.infiniteSlider) {
349					
350					if(nodeOffset <= (tempSliderMax * -1)) {
351						
352						var scrollerWidth = $(node).width();
353							
354						var lowSlideNumber = 0;
355						var lowSlideOffset = tempSlideNodeOffsets[0];
356						for(var i = 0; i < tempSlideNodeOffsets.length; i++) {
357							
358							if(tempSlideNodeOffsets[i] < lowSlideOffset) {
359								lowSlideOffset = tempSlideNodeOffsets[i];
360								lowSlideNumber = i;
361							}
362							
363						}
364						
365						var newOffset = tempSliderMin + scrollerWidth;
366						tempSlideNodeOffsets[lowSlideNumber] = newOffset;
367						
368						tempSliderMin = tempChildrenOffsets[1] * -1 + centeredSlideOffset;
369						tempSliderMax = tempSliderMin + scrollerWidth - stageWidth;
370
371						tempChildrenOffsets.splice(0, 1);
372						tempChildrenOffsets.splice(tempChildrenOffsets.length, 0, newOffset * -1 + centeredSlideOffset);
373
374						tempInfiniteSliderOffset++;
375						
376					}
377					if(nodeOffset >= (tempSliderMin * -1)) {
378						
379						var scrollerWidth = $(node).width();
380						
381						var highSlideNumber = 0;
382						var highSlideOffset = tempSlideNodeOffsets[0];
383						for(var i = 0; i < tempSlideNodeOffsets.length; i++) {
384							
385							if(tempSlideNodeOffsets[i] > highSlideOffset) {
386								highSlideOffset = tempSlideNodeOffsets[i];
387								highSlideNumber = i;
388							}
389							
390						}
391
392						var newOffset = tempSliderMin - $(slideNodes[highSlideNumber]).outerWidth(true);
393						tempSlideNodeOffsets[highSlideNumber] = newOffset;
394						
395						tempChildrenOffsets.splice(0, 0, newOffset * -1 + centeredSlideOffset);
396						tempChildrenOffsets.splice(tempChildrenOffsets.length-1, 1);
397
398						tempSliderMin = tempChildrenOffsets[0] * -1 + centeredSlideOffset;
399						tempSliderMax = tempSliderMin + scrollerWidth - stageWidth;
400
401						tempInfiniteSliderOffset--;
402					
403					}
404						
405				}
406				
407				distanceOffsetArray[distanceOffsetArray.length] = nodeOffset;
408				xScrollDistanceArray[xScrollDistanceArray.length] = xScrollDistance;
409
410			}
411
412			var slideChanged = false;
413			var newChildOffset = helpers.calcActiveOffset(settings, nodeOffset, tempChildrenOffsets, stageWidth, tempInfiniteSliderOffset, numberOfSlides, activeChildOffsets[sliderNumber], sliderNumber);
414			var tempOffset = (newChildOffset + tempInfiniteSliderOffset + numberOfSlides)%numberOfSlides;
415
416			if(settings.snapToChildren) {
417			
418				if(settings.infiniteSlider) {
419				
420					if(tempOffset != activeChildInfOffsets[sliderNumber]) {
421						slideChanged = true;
422					}
423						
424				} else {
425				
426					if(newChildOffset != activeChildOffsets[sliderNumber]) {
427						slideChanged = true;
428					}
429				
430				}
431
432				if((snapDirection < 0) && !slideChanged) {
433				
434					newChildOffset++;
435					
436					if((newChildOffset >

436= childrenOffsets.length) && !settings.infinteSlider) newChildOffset = childrenOffsets.length - 1;
437					
438				} else if((snapDirection > 0) && !slideChanged) {
439				
440					newChildOffset--;
441					
442					if((newChildOffset < 0) && !settings.infinteSlider) newChildOffset = 0;
443					
444				}
445			
446			}
447
448			if(settings.snapToChildren || (((nodeOffset > (sliderMin[sliderNumber] * -1)) || (nodeOffset < (sliderMax[sliderNumber] * -1))) && !settings.infiniteSlider)) {
449				
450				nodeOffset = helpers.getSliderOffset(node, 'x');
451				distanceOffsetArray.splice(0, distanceOffsetArray.length);
452				
453				while((nodeOffset < (tempChildrenOffsets[newChildOffset] - 0.5)) || (nodeOffset > (tempChildrenOffsets[newChildOffset] + 0.5))) {
454					
455					nodeOffset = ((nodeOffset - (tempChildrenOffsets[newChildOffset])) * snapFrictionCoefficient) + (tempChildrenOffsets[newChildOffset]);
456					distanceOffsetArray[distanceOffsetArray.length] = nodeOffset;
457					
458				}
459
460				distanceOffsetArray[distanceOffsetArray.length] = tempChildrenOffsets[newChildOffset];
461	
462			}
463
464			var jStart = 1;
465			if((distanceOffsetArray.length%2) != 0) {
466				jStart = 0;
467			}
468			
469			var lastTimeoutRegistered = 0;
470			var count = 0;
471			
472			for(var j = 0; j < scrollTimeouts.length; j++) {
473				clearTimeout(scrollTimeouts[j]);
474			}
475			
476			var endOffset = (newChildOffset + tempInfiniteSliderOffset + numberOfSlides)%numberOfSlides;
477
478			var lastCheckOffset = 0;
479			for(var j = jStart; j < distanceOffsetArray.length; j = j + 2) {
480				
481				if((j == jStart) || (Math.abs(distanceOffsetArray[j] - lastCheckOffset) > 1) || (j >= (distanceOffsetArray.length - 2))) {
482				
483					lastCheckOffset	= distanceOffsetArray[j];
484					
485					scrollTimeouts[scrollTimeouts.length] = helpers.slowScrollHorizontalIntervalTimer(scrollIntervalTime * j, node, slideNodes, distanceOffsetArray[j], scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, newChildOffset, originalOffsets, childrenOffsets, infiniteSliderWidth, numberOfSlides, sliderNumber, centeredSlideOffset, endOffset, settings);
486				
487				}
488				
489			}
490			
491			var slideChanged = false;
492			var tempOffset = (newChildOffset + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
493			
494			if(settings.infiniteSlider) {
495				
496				if(tempOffset != activeChildInfOffsets[sliderNumber]) {
497					slideChanged = true;
498				}
499					
500			} else {
501			
502				if(newChildOffset != activeChildOffsets[sliderNumber]) {
503					slideChanged = true;
504				}
505			
506			}
507				
508			if(settings.onSlideComplete != '') {
509
510				scrollTimeouts[scrollTimeouts.length] = helpers.onSlideCompleteTimer(scrollIntervalTime * (j + 1), settings, node, $(node).children(':eq(' + tempOffset + ')'), tempOffset, sliderNumber);
511				
512			}
513			
514			slideTimeouts[sliderNumber] = scrollTimeouts;
515			
516			helpers.hideScrollbar(settings, scrollTimeouts, j, distanceOffsetArray, scrollbarClass, scrollbarWidth, stageWidth, scrollMargin, scrollBorder, sliderNumber);
517				
518		},
519		
520		onSlideComplete: function(settings, node, slideNode, newChildOffset, sliderNumber) {
521			
522			var isChanged = (onChangeEventLastFired[sliderNumber] != newChildOffset) ? true : false;
523			var args = new helpers.args(settings, $(node), slideNode, newChildOffset, newChildOffset, isChanged);
524			$(node).parent().data('args', args);
525				
526			if(settings.onSlideComplete != '') {
527				
528				settings.onSlideComplete(args);
529			
530			}
531			
532			onChangeEventLastFired[sliderNumber] = newChildOffset;
533		
534		},
535		
536		getSliderOffset: function(node, xy) {
537			
538			var sliderOffset = 0;
539			if(xy == 'x') {
540				xy = 4;
541			} else {
542				xy = 5;
543			}
544			
545			if(has3DTransform && !isIe7 && !isIe8) {
546				
547				var transforms = new Array('-webkit-transform', '-moz-transform', 'transform');
548				
549				for(var i = 0; i < transforms.length; i++) {
550					
551					if($(node).css(transforms[i]) != undefined) {
552						
553						if($(node).css(transforms[i]).length > 0) {
554						
555							var transformArray = $(node).css(transforms[i]).split(',');
556							
557							break;
558							
559						}
560					
561					}
562				
563				}
564				
565				sliderOffset = parseInt(transformArray[xy], 10);
566					
567			} else {
568			
569				sliderOffset = parseInt($(node).css('left'), 10);
570			
571			}
572			
573			return sliderOffset;
574		
575		},
576		
577		setSliderOffset: function(node, sliderOffset) {
578			
579			if(has3DTransform && !isIe7 && !isIe8) {
580				
581				$(node).css({
582					'webkitTransform': 'matrix(1,0,0,1,' + sliderOffset + ',0)',
583					'MozTransform': 'matrix(1,0,0,1,' + sliderOffset + ',0)',
584					'transform': 'matrix(1,0,0,1,' + sliderOffset + ',0)'
585				});
586			
587			} else {
588
589				$(node).css({
590					left: sliderOffset + 'px'
591				});
592			
593			}
594						
595		},
596		
597		setBrowserInfo: function() {
598			
599			if(navigator.userAgent.match('WebKit') != null) {
600				isWebkit = true;
601				grabOutCursor = '-webkit-grab';
602				grabInCursor = '-webkit-grabbing';
603			} else if(navigator.userAgent.match('Gecko') != null) {
604				isGecko = true;
605				grabOutCursor = 'move';
606				grabInCursor = '-moz-grabbing';
607			} else if(navigator.userAgent.match('MSIE 7') != null) {
608				isIe7 = true;
609				isIe = true;
610			} else if(navigator.userAgent.match('MSIE 8') != null) {
611				isIe8 = true;
612				isIe = true;
613			} else if(navigator.userAgent.match('MSIE 9') != null) {
614				isIe9 = true;
615				isIe = true;
616			}
617			
618		},
619		
620		has3DTransform: function() {
621			
622			var has3D = false;

623			
624			var testElement = $('<div />').css({
625				'webkitTransform': 'matrix(1,1,1,1,1,1)',
626				'MozTransform': 'matrix(1,1,1,1,1,1)',
627				'transform': 'matrix(1,1,1,1,1,1)'
628			});
629			
630			if(testElement.attr('style') == '') {
631				has3D = false;
632			} else if(testElement.attr('style') != undefined) {
633				has3D = true;
634			}
635			
636			return has3D;
637			
638		},
639		
640		getSlideNumber: function(slide, sliderNumber, numberOfSlides) {
641			
642			return (slide - infiniteSliderOffset[sliderNumber] + numberOfSlides) % numberOfSlides;
643		
644		}, 
645
646        calcActiveOffset: function(settings, offset, childrenOffsets, stageWidth, infiniteSliderOffset, numberOfSlides, activeChildOffset, sliderNumber) {
647								
648			var isFirst = false;
649			var arrayOfOffsets = new Array();
650			var newChildOffset;
651
652			for(var i = 0; i < childrenOffsets.length; i++) {
653				
654				if((childrenOffsets[i] <= offset) && (childrenOffsets[i] > (offset - stageWidth))) {
655				
656					if(!isFirst && (childrenOffsets[i] != offset)) {
657						
658						arrayOfOffsets[arrayOfOffsets.length] = childrenOffsets[i-1];
659						
660					}
661					
662					arrayOfOffsets[arrayOfOffsets.length] = childrenOffsets[i];
663					
664					isFirst = true;
665						
666				}
667			
668			}
669			
670			if(arrayOfOffsets.length == 0) {
671				arrayOfOffsets[0] = childrenOffsets[childrenOffsets.length - 1];
672			}
673			
674			var distance = stageWidth;
675			var closestChildOffset = 0;
676			
677			for(var i = 0; i < arrayOfOffsets.length; i++) {
678				
679				var newDistance = Math.abs(offset - arrayOfOffsets[i]);
680				
681				if(newDistance < distance) {
682					closestChildOffset = arrayOfOffsets[i];
683					distance = newDistance;
684				}
685				
686			}
687			
688			for(var i = 0; i < childrenOffsets.length; i++) {
689				
690				if(closestChildOffset == childrenOffsets[i]) {
691					
692					newChildOffset = i;
693					
694				}
695				
696			}
697			
698			return newChildOffset;
699		
700		},
701		
702		changeSlide: function(slide, node, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings) {
703
704			helpers.autoSlidePause(sliderNumber);
705			
706			for(var j = 0; j < scrollTimeouts.length; j++) {
707				clearTimeout(scrollTimeouts[j]);
708			}
709			
710			var steps = Math.ceil(settings.autoSlideTransTimer / 10) + 1;
711			var startOffset = helpers.getSliderOffset(node, 'x');
712			var endOffset = childrenOffsets[slide];
713			var offsetDiff = endOffset - startOffset;
714			
715			if(settings.infiniteSlider) {
716				
717				slide = (slide - infiniteSliderOffset[sliderNumber] + numberOfSlides * 2)%numberOfSlides;
718				
719				var appendArray = false;
720				if((slide == 0) && (numberOfSlides == 2)) {
721					
722					slide = numberOfSlides;
723					childrenOffsets[slide] = childrenOffsets[slide-1] - $(slideNodes).eq(0).outerWidth(true);
724					appendArray = true;
725					
726				}
727				
728				endOffset = childrenOffsets[slide];
729				offsetDiff = endOffset - startOffset;
730				
731				var offsets = new Array(childrenOffsets[slide] - $(node).width(), childrenOffsets[slide] + $(node).width());
732				
733				if(appendArray) {
734					childrenOffsets.splice(childrenOffsets.length-1, 1);
735				}
736				
737				for(var i = 0; i < offsets.length; i++) {
738					
739					if(Math.abs(offsets[i] - startOffset) < Math.abs(offsetDiff)) {
740						offsetDiff = (offsets[i] - startOffset);
741					}
742				
743				}
744				
745			}
746			
747			var stepArray = new Array();
748			var t;
749			var nextStep;
750
751			helpers.showScrollbar(settings, scrollbarClass);
752
753			for(var i = 0; i <= steps; i++) {
754
755				t = i;
756				t /= steps;
757				t--;
758				nextStep = startOffset + offsetDiff*(Math.pow(t,5) + 1);
759				
760				stepArray[stepArray.length] = nextStep;
761				
762			}
763			
764			var lastCheckOffset = 0;
765			for(var i = 0; i < stepArray.length; i++) {
766				
767				if((i == 0) || (Math.abs(stepArray[i] - lastCheckOffset) > 1) || (i >= (stepArray.length - 2))) {
768
769					lastCheckOffset	= stepArray[i];
770					
771					scrollTimeouts[i] = helpers.slowScrollHorizontalIntervalTimer(scrollIntervalTime * (i + 1), node, slideNodes, stepArray[i], scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, slide, originalOffsets, childrenOffsets, infiniteSliderWidth, numberOfSlides, sliderNumber, 

771centeredSlideOffset, slide, settings);
772						
773				}
774				
775				if((i == 0) && (settings.onSlideStart != '')) {
776					var tempOffset = (activeChildOffsets[sliderNumber] + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;		
777				
778					settings.onSlideStart(new helpers.args(settings, node, $(node).children(':eq(' + tempOffset + ')'), tempOffset, slide, false));
779				}
780					
781			}
782
783			var slideChanged = false;
784			var tempOffset = (slide + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
785			
786			if(settings.infiniteSlider) {
787				
788				if(tempOffset != activeChildInfOffsets[sliderNumber]) {
789					slideChanged = true;
790				}
791					
792			} else {
793			
794				if(slide != activeChildOffsets[sliderNumber]) {
795					slideChanged = true;
796				}
797			
798			}
799				
800			if(slideChanged && (settings.onSlideComplete != '')) {
801
802				scrollTimeouts[scrollTimeouts.length] = helpers.onSlideCompleteTimer(scrollIntervalTime * (i + 1), settings, node, $(node).children(':eq(' + tempOffset + ')'), tempOffset, sliderNumber);
803			}
804			
805			slideTimeouts[sliderNumber] = scrollTimeouts;
806			
807			helpers.hideScrollbar(settings, scrollTimeouts, i, stepArray, scrollbarClass, scrollbarWidth, stageWidth, scrollMargin, scrollBorder, sliderNumber);
808			
809			helpers.autoSlide(node, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
810			
811		},
812		
813		autoSlide: function(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings) {
814			
815			if(!settings.autoSlide) return false;
816			
817			helpers.autoSlidePause(sliderNumber);
818
819			autoSlideTimeouts[sliderNumber] = setTimeout(function() {
820
821				if(!settings.infiniteSlider && (activeChildOffsets[sliderNumber] > childrenOffsets.length-1)) {
822					activeChildOffsets[sliderNumber] = activeChildOffsets[sliderNumber] - numberOfSlides;
823				}
824				
825				var nextSlide = (activeChildOffsets[sliderNumber] + infiniteSliderOffset[sliderNumber] + numberOfSlides + 1)%numberOfSlides;
826
827				helpers.changeSlide(nextSlide, scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
828				
829				helpers.autoSlide(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
830				
831			}, settings.autoSlideTimer + settings.autoSlideTransTimer);
832			
833		},
834		
835		autoSlidePause: function(sliderNumber) {
836			
837			clearTimeout(autoSlideTimeouts[sliderNumber]);
838
839		},
840		
841		isUnselectable: function(node, settings) {
842
843			if(settings.unselectableSelector != '') {
844				if($(node).closest(settings.unselectableSelector).size() == 1) return true;
845			}
846			
847			return false;
848			
849		},
850		
851		/* timers */
852		slowScrollHorizontalIntervalTimer: function(scrollIntervalTime, node, slideNodes, step, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, slide, originalOffsets, childrenOffsets, infiniteSliderWidth, numberOfSlides, sliderNumber, centeredSlideOffset, endOffset, settings) {
853		
854			var scrollTimeout = setTimeout(function() {
855				helpers.slowScrollHorizontalInterval(node, slideNodes, step, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, slide, originalOffsets, childrenOffsets, infiniteSliderWidth, numberOfSlides, sliderNumber, centeredSlideOffset, endOffset, settings);
856			}, scrollIntervalTime);
857			
858			return scrollTimeout;
859		
860		},
861		
862		onSlideCompleteTimer: function(scrollIntervalTime, settings, node, slideNode, slide, scrollbarNumber) {
863			
864			var scrollTimeout = setTimeout(function() {

865				helpers.onSlideComplete(settings, node, slideNode, slide, scrollbarNumber);
866			}, scrollIntervalTime);
867			
868			return scrollTimeout;
869		
870		},
871		
872		hideScrollbarIntervalTimer: function(scrollIntervalTime, newOffset, opacity, scrollbarClass, scrollbarWidth, stageWidth, scrollMargin, scrollBorder, sliderNumber, settings) {
873
874			var scrollTimeout = setTimeout(function() {
875				helpers.hideScrollbarInterval(newOffset, opacity, scrollbarClass, scrollbarWidth, stageWidth, scrollMargin, scrollBorder, sliderNumber, settings);
876			}, scrollIntervalTime);
877		
878			return scrollTimeout;
879		
880		},
881						
882		args: function(settings, node, activeSlideNode, newChildOffset, targetSlideOffset, isChanged) {
883
884			this.settings = settings;
885			this.data = $(node).parent().data('iosslider');
886			this.slideChanged = isChanged;
887			this.sliderObject = node;
888			this.sliderContainerObject = $(node).parent();
889			this.currentSlideObject = activeSlideNode;
890			this.currentSlideNumber = newChildOffset + 1;
891			this.targetSlideObject = $(node).children(':eq(' + targetSlideOffset + ')');
892			this.targetSlideNumber = targetSlideOffset + 1;
893			this.currentSliderOffset = helpers.getSliderOffset(node, 'x') * -1;
894			
895			try {
896				if($(node).parent().data('args') == undefined) {
897					this.prevSlideNumber = settings.startAtSlide;
898				} else if($(node).parent().data('args').prevSlideNumber == this.currentSlideNumber) {
899					this.prevSlideNumber = $(node).parent().data('args').currentSlideNumber;					
900				} else {
901					this.prevSlideNumber = $(node).parent().data('args').prevSlideNumber;
902				}
903				
904				this.prevSlideObject = $(node).children(':eq(' + this.prevSlideNumber + ')');
905			} catch(e) {}
906
907		},
908		
909		preventDrag: function(event) {
910			event.preventDefault();
911		},
912		
913		preventClick: function(event) {
914			event.stopImmediatePropagation();
915			return false;
916		},
917		
918		enableClick: function() {
919			return true;
920		}
921        
922    }
923    
924    helpers.setBrowserInfo();
925    
926    var methods = {
927		
928		init: function(options, node) {
929			
930			has3DTransform = helpers.has3DTransform();
931			
932			var settings = $.extend(true, {
933				'elasticPullResistance': 0.6, 		
934				'frictionCoefficient': 0.92,
935				'elasticFrictionCoefficient': 0.6,
936				'snapFrictionCoefficient': 0.92,
937				'snapToChildren': false,
938				'snapSlideCenter': false,
939				'startAtSlide': 1,
940				'scrollbar': false,
941				'scrollbarDrag': false,
942				'scrollbarHide': true,
943				'scrollbarLocation': 'top',
944				'scrollbarContainer': '',
945				'scrollbarOpacity': 0.4,
946				'scrollbarHeight': '4px',
947				'scrollbarBorder': '0',
948				'scrollbarMargin': '5px',
949				'scrollbarBackground': '#000',
950				'scrollbarBorderRadius': '100px',
951				'scrollbarShadow': '0 0 0 #000',
952				'scrollbarElasticPullResistance': 0.9,
953				'desktopClickDrag': false,
954				'keyboardControls': false,
955				'responsiveSlideContainer': true,
956				'responsiveSlides': true,
957				'navSlideSelector': '',
958				'navPrevSelector': '',
959				'navNextSelector': '',
960				'autoSlideToggleSelector': '',
961				'autoSlide': false,
962				'autoSlideTimer': 5000,
963				'autoSlideTransTimer': 750,
964				'infiniteSlider': false,
965				'stageCSS': {
966					position: 'relative',
967					top: '0',
968					left: '0',
969					overflow: 'hidden',
970					zIndex: 1
971				},
972				'unselectableSelector': '',
973				'onSliderLoaded': '',
974				'onSliderUpdate': '',
975				'onSliderResize': '',
976				'onSlideStart': '',
977				'onSlideChange': '',
978				'onSlideComplete': ''
979			}, options);
980			
981			if(node == undefined) {
982				node = this;
983			}
984			
985			return $(node).each(function(i) {
986				
987				scrollbarNumber++;
988				var sliderNumber = scrollbarNumber;
989				var scrollTimeouts = new Array();
990				iosSliderSettings[sliderNumber] = settings;
991				sliderMin[sliderNumber] = 0;
992				sliderMax[sliderNumber] = 0;
993				var minTouchpoints = 0;
994				var xCurrentScrollRate = new Array(0, 0);
995				var yCurrentScrollRate = new Array(0, 0);
996				var scrollbarBlockClass = 'scrollbarBlock' + scrollbarNumber;
997				var scrollbarClass = 'scrollbar' + scrollbarNumber;
998				var scrollbarNode;
999				var scrollbarBlockNode;
1000				var scrollbarStageWidth;
1001				var scrollbarWidth;
1002				var containerWidth;
1003				var containerHeight;
1004				var centeredSlideOffset = 0;
1005				var stageNode = $(this);
1006				var stageWidth;
1007				var stageHeight;
1008				var slideWidth;
1009				var scrollMargin;
1010				var scrollBorder;
1011				var lastTouch;
1012				var isFirstInit = true;
1013				var newChildOffset = -1;
1014				var webkitTransformArray = new Array();
1015				var childrenOffsets;
1016				var originalOffsets = new Array();
1017				var scrollbarStartOpacity = 0;
1018				var xScrollStartPosition = 0;
1019				var yScrollStartPosition = 0;
1020				var currentTouches = 0;
1021				var scrollerNode = $(this).children(':first-child');

1022				var slideNodes;
1023				var slideNodeWidths;
1024				var slideNodeOuterWidths;
1025				var numberOfSlides = $(scrollerNode).children().not('script').size();
1026				var xScrollStarted = false;
1027				var lastChildOffset = 0;
1028				var isMouseDown = false;
1029				var currentSlider = undefined;
1030				var sliderStopLocation = 0;
1031				var infiniteSliderWidth;
1032				infiniteSliderOffset[sliderNumber] = 0;
1033				var shortContent = false;
1034				onChangeEventLastFired[sliderNumber] = -1;
1035				var isAutoSlideToggleOn = false;
1036				iosSliders[sliderNumber] = stageNode;
1037				isEventCleared[sliderNumber] = false;
1038				var currentEventNode;
1039				var intermediateChildOffset = 0;
1040				var tempInfiniteSliderOffset = 0;
1041				var preventXScroll = false;
1042				var snapOverride = false;
1043				var scrollerWidth;
1044				var clickEvent = isTouch ? 'touchstart.iosSliderEvent' : 'click.iosSliderEvent';
1045				var anchorEvents;
1046				var onclickEvents;
1047				var allScrollerNodeChildren;
1048				touchLocks[sliderNumber] = false;
1049				slideTimeouts[sliderNumber] = new Array();
1050				if(settings.scrollbarDrag) {
1051					settings.scrollbar = true;
1052					settings.scrollbarHide = false;

1053				}
1054				var $this = $(this);
1055				var data = $this.data('iosslider');	
1056				if(data != undefined) return true;
1057           		
1058           		$(this).find('img').bind('dragstart.iosSliderEvent', function(event) { event.preventDefault(); });
1059
1060				if(settings.infiniteSlider) {
1061					settings.scrollbar = false;
1062				}
1063						
1064				if(settings.scrollbar) {
1065					
1066					if(settings.scrollbarContainer != '') {
1067						$(settings.scrollbarContainer).append("<div class = '" + scrollbarBlockClass + "'><div class = '" + scrollbarClass + "'></div></div>");
1068					} else {
1069						$(scrollerNode).parent().append("<div class = '" + scrollbarBlockClass + "'><div class = '" + scrollbarClass + "'></div></div>");
1070					}
1071				
1072				}
1073				
1074				if(!init()) return true;
1075				
1076				$(this).find('a').bind('mousedown', helpers.preventDrag);
1077				$(this).find("[onclick]").bind('click', helpers.preventDrag).each(function() {
1078					
1079					$(this).data('onclick', this.onclick);
1080				
1081				});
1082				
1083				var newChildOffset = helpers.calcActiveOffset(settings, helpers.getSliderOffset($(scrollerNode), 'x'), childrenOffsets, stageWidth, infiniteSliderOffset[sliderNumber], numberOfSlides, undefined, sliderNumber);
1084				var tempOffset = (newChildOffset + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
1085				
1086				var args = new helpers.args(settings, scrollerNode, $(scrollerNode).children(':eq(' + tempOffset + ')'), tempOffset, tempOffset, false);
1087				$(stageNode).data('args', args);
1088
1089				if(settings.onSliderLoaded != '') {
1090
1091					settings.onSliderLoaded(args);
1092					
1093				}
1094				
1095				onChangeEventLastFired[sliderNumber] = tempOffset;
1096
1097				function init() {
1098					
1099					helpers.autoSlidePause(sliderNumber);
1100					
1101					anchorEvents = $(scrollerNode).find('a');
1102					onclickEvents = $(scrollerNode).find('[onclick]');
1103					allScrollerNodeChildren = $(scrollerNode).find('*');
1104					
1105					$(stageNode).css('width', '');
1106					$(stageNode).css('height', '');
1107					$(scrollerNode).css('width', '');
1108					slideNodes = $(scrollerNode).children().not('script').get();
1109					slideNodeWidths = new Array();
1110					slideNodeOuterWidths = new Array();
1111					
1112					$(slideNodes).css('width', '');
1113					
1114					sliderMax[sliderNumber] = 0;
1115					childrenOffsets = new Array();
1116					containerWidth = $(stageNode).parent().width();
1117					stageWidth = $(stageNode).outerWidth(true);
1118					
1119					if(settings.responsiveSlideContainer) {
1120						stageWidth = ($(stageNode).outerWidth(true) > containerWidth) ? containerWidth : $(stageNode).outerWidth(true);
1121					}
1122
1123					$(stageNode).css({
1124						position: settings.stageCSS.position,
1125						top: settings.stageCSS.top,
1126						left: settings.stageCSS.left,
1127						overflow: settings.stageCSS.overflow,
1128						zIndex: settings.stageCSS.zIndex,
1129						'webkitPerspective': 1000,
1130						'webkitBackfaceVisibility': 'hidden',
1131						width: stageWidth
1132					});
1133					
1134					$(settings.unselectableSelector).css({
1135						cursor: 'default'
1136					});
1137						
1138					for(var j = 0; j < slideNodes.length; j++) {
1139						
1140						slideNodeWidths[j] = $(slideNodes[j]).width();
1141						slideNodeOuterWidths[j] = $(slideNodes[j]).outerWidth(true);
1142						var newWidth = slideNodeOuterWidths[j];
1143						
1144						if(settings.responsiveSlides) {
1145
1146							if(slideNodeOuterWidths[j] > stageWidth) {
1147								
1148								newWidth = stageWidth + (slideNodeOuterWidths[j] - slideNodeWidths[j]) * -1;
1149								
1150							} else {
1151
1152								newWidth = slideNodeWidths[j];
1153								
1154							}
1155							
1156							$(slideNodes[j]).css({
1157								width: newWidth
1158							});
1159					
1160						}
1161						
1162						$(slideNodes[j]).css({
1163							'webkitBackfaceVisibility': 'hidden',
1164							position: 'absolute',
1165							top: 0
1166						});
1167						
1168						childrenOffsets[j] = sliderMax[sliderNumber] * -1;
1169						
1170						sliderMax[sliderNumber] = sliderMax[sliderNumber] + newWidth;
1171					
1172					}
1173					
1174					if(settings.snapSlideCenter) {
1175						centeredSlideOffset = (stageWidth - slideNodeOuterWidths[0]) * 0.5;
1176						
1177						if(settings.responsiveSlides && (slideNodeOuterWidths[0] > stageWidth)) {
1178							centeredSlideOffset = 0;
1179						}
1180					}
1181					
1182					sliderAbsMax[sliderNumber] = sliderMax[sliderNumber] * 2;
1183					
1184					for(var j = 0; j < slideNodes.length; j++) {
1185						
1186						helpers.setSliderOffset($(slideNodes[j]), childrenOffsets[j] * -1 + sliderMax[sliderNumber] + centeredSlideOffset);
1187						
1188						childrenOffsets[j] = childrenOffsets[j] - sliderMax[sliderNumber];
1189					
1190					}
1191					

1192					if(!settings.infiniteSlider && !settings.snapSlideCenter) {
1193					
1194						for(var i = 0; i < childrenOffsets.length; i++) {
1195							
1196							if(childrenOffsets[i] <= ((sliderMax[sliderNumber] * 2 - stageWidth) * -1)) {
1197								break;
1198							}
1199							
1200							lastChildOffset = i;
1201							
1202						}
1203						
1204						childrenOffsets.splice(lastChildOffset + 1, childrenOffsets.length);
1205						childrenOffsets[childrenOffsets.length] = (sliderMax[sliderNumber] * 2 - stageWidth) * -1;
1206					
1207					}
1208					for(var i = 0; i < childrenOffsets.length; i++) {
1209						originalOffsets[i] = childrenOffsets[i];
1210					}
1211					
1212					if(isFirstInit) {
1213						settings.startAtSlide = (iosSliderSettings[sliderNumber].startAtSlide > childrenOffsets.length) ? childrenOffsets.length : iosSliderSettings[sliderNumber].startAtSlide;
1214						if(settings.infiniteSlider) {
1215							settings.startAtSlide = (iosSliderSettings[sliderNumber].startAtSlide - 1 + numberOfSlides)%numberOfSlides;
1216							activeChildOffsets[sliderNumber] = (iosSliderSettings[sliderNumber].startAtSlide);
1217						} else {
1218							settings.startAtSlide = ((iosSliderSettings[sliderNumber].startAtSlide - 1) < 0) ? childrenOffsets.length-1 : iosSliderSettings[sliderNumber].startAtSlide;	
1219							activeChildOffsets[sliderNumber] = (iosSliderSettings[sliderNumber].startAtSlide-1);
1220						}
1221						activeChildInfOffsets[sliderNumber] = activeChildOffsets[sliderNumber];
1222					}
1223					
1224					sliderMin[sliderNumber] = sliderMax[sliderNumber] + centeredSlideOffset;
1225					
1226					$(scrollerNode).css({
1227						position: 'relative',
1228						cursor: grabOutCursor,
1229						'webkitPerspective': '0',
1230						'webkitBackfaceVisibility': 'hidden',
1231						width: sliderMax[sliderNumber] + 'px'
1232					});
1233					
1234					scrollerWidth = sliderMax[sliderNumber];
1235					sliderMax[sliderNumber] = sliderMax[sliderNumber] * 2 - stageWidth + centeredSlideOffset * 2;
1236					
1237					shortContent = (scrollerWidth < stageWidth) ? true : false;
1238
1239					if(shortContent) {
1240						
1241						$(scrollerNode).css({
1242							cursor: 'default'
1243						});
1244						
1245					}
1246					
1247					containerHeight = $(stageNode).parent().outerHeight(true);
1248					stageHeight = $(stageNode).height();
1249					
1250					if(settings.responsiveSlideContainer) {
1251						stageHeight = (stageHeight > containerHeight) ? containerHeight : stageHeight;
1252					}
1253					
1254					$(stageNode).css({
1255						height: stageHeight
1256					});
1257
1258					helpers.setSliderOffset(scrollerNode, childrenOffsets[activeChildOffsets[sliderNumber]]);
1259					
1260					if(settings.infiniteSlider && !shortContent) {
1261						
1262						var currentScrollOffset = helpers.getSliderOffset($(scrollerNode), 'x');
1263						var count = (infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides * -1;
1264
1265						while(count < 0) {
1266								
1267							var lowSlideNumber = 0;
1268							var lowSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
1269							$(slideNodes).each(function(i) {
1270								
1271								if(helpers.getSliderOffset(this, 'x') < lowSlideOffset) {
1272									lowSlideOffset = helpers.getSliderOffset(this, 'x');
1273									lowSlideNumber = i;
1274								}
1275								
1276							});
1277							
1278							var newOffset = sliderMin[sliderNumber] + scrollerWidth;
1279							helpers.setSliderOffset($(slideNodes)[lowSlideNumber], newOffset);
1280							
1281							sliderMin[sliderNumber] = childrenOffsets[1] * -1 + centeredSlideOffset;
1282							sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
1283
1284							childrenOffsets.splice(0, 1);
1285							childrenOffsets.splice(childrenOffsets.length, 0, newOffset * -1 + centeredSlideOffset);
1286
1287							count++;
1288							
1289						}
1290						
1291						while(((childrenOffsets[0] * -1 - scrollerWidth + centeredSlideOffset) > 0) && settings.snapSlideCenter && isFirstInit) {
1292							
1293							var highSlideNumber = 0;
1294							var highSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
1295							$(slideNodes).each(function(i) {
1296								
1297								if(helpers.getSliderOffset(this, 'x') > highSlideOffset) {
1298									highSlideOffset = helpers.getSliderOffset(this, 'x');
1299									highSlideNumber = i;
1300								}
1301								
1302							});
1303
1304							var newOffset = sliderMin[sliderNumber] - slideNodeOuterWidths[highSlideNumber];
1305							helpers.setSliderOffset($(slideNodes)[highSlideNumber], newOffset);
1306							
1307							childrenOffsets.splice(0, 0, newOffset * -1 + centeredSlideOffset);
1308							childrenOffsets.splice(childrenOffsets.length-1, 1);
1309
1310							sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
1311							sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
1312
1313							infiniteSliderOffset[sliderNumber]--;
1314							activeChildOffsets[sliderNumber]++;
1315							
1316						}
1317					
1318					}
1319					
1320					helpers.setSliderOffset(scrollerNode, childrenOffsets[activeChildOffsets[sliderNumber]]);
1321					

1322					if(!isTouch && !settings.desktopClickDrag) {
1323						
1324						$(scrollerNode).css({
1325							cursor: 'default'
1326						});
1327						
1328					}
1329					
1330					if(settings.scrollbar) {
1331						
1332						$('.' + scrollbarBlockClass).css({ 
1333							margin: settings.scrollbarMargin,
1334							overflow: 'hidden',
1335							display: 'none'
1336						});
1337						
1338						$('.' + scrollbarBlockClass + ' .' + scrollbarClass).css({ 
1339							border: settings.scrollbarBorder
1340						});
1341						
1342						scrollMargin = parseInt($('.' + scrollbarBlockClass).css('marginLeft')) + parseInt($('.' + scrollbarBlockClass).css('marginRight'));
1343						scrollBorder = parseInt($('.' + scrollbarBlockClass + ' .' + scrollbarClass).css('borderLeftWidth'), 10) + parseInt($('.' + scrollbarBlockClass + ' .' + scrollbarClass).css('borderRightWidth'), 10);
1344						scrollbarStageWidth = (settings.scrollbarContainer != '') ? $(settings.scrollbarContainer).width() : stageWidth;
1345						scrollbarWidth = (scrollbarStageWidth - scrollMargin) / numberOfSlides;
1346		
1347						if(!settings.scrollbarHide) {
1348							scrollbarStartOpacity = settings.scrollbarOpacity;
1349						}
1350						
1351						$('.' + scrollbarBlockClass).css({ 
1352							position: 'absolute',
1353							left: 0,
1354							width: scrollbarStageWidth - scrollMargin + 'px',
1355							margin: settings.scrollbarMargin
1356						});
1357						
1358						if(settings.scrollbarLocation == 'top') {
1359							$('.' + scrollbarBlockClass).css('top', '0');
1360						} else {
1361							$('.' + scrollbarBlockClass).css('bottom', '0');
1362						}
1363						
1364						$('.' + scrollbarBlockClass + ' .' + scrollbarClass).css({ 
1365							borderRadius: settings.scrollbarBorderRadius,
1366							background: settings.scrollbarBackground,
1367							height: settings.scrollbarHeight,
1368							width: scrollbarWidth - scrollBorder + 'px',
1369							minWidth: settings.scrollbarHeight,
1370							border: settings.scrollbarBorder,
1371							'webkitPerspective': 1000,
1372							'webkitBackfaceVisibility': 'hidden',
1373							'position': 'relative',
1374							opacity: scrollbarStartOpacity,
1375							filter: 'alpha(opacity:' + (scrollbarStartOpacity * 100) + ')',
1376							boxShadow: settings.scrollbarShadow
1377						});
1378						
1379						helpers.setSliderOffset($('.' + scrollbarBlockClass + ' .' + scrollbarClass), Math.floor((childrenOffsets[activeChildOffsets[sliderNumber]] * -1 - sliderMin[sliderNumber] + centeredSlideOffset) / (sliderMax[sliderNumber] - sliderMin[sliderNumber]) * (scrollbarStageWidth - scrollMargin - scrollbarWidth)));
1380		
1381						$('.' + scrollbarBlockClass).css({
1382							display: 'block'
1383						});
1384						
1385						scrollbarNode = $('.' + scrollbarBlockClass + ' .' + scrollbarClass);
1386						scrollbarBlockNode = $('.' + scrollbarBlockClass);						
1387						
1388					}
1389					
1390					if(settings.scrollbarDrag && !shortContent) {
1391						$('.' + scrollbarBlockClass + ' .' + scrollbarClass).css({
1392							cursor: grabOutCursor
1393						});
1394					}
1395					
1396					if(settings.infiniteSlider) {
1397					
1398						infiniteSliderWidth = (sliderMax[sliderNumber] + stageWidth) / 3;
1399						
1400					}
1401					
1402					if(settings.navSlideSelector != '') {
1403								
1404						$(settings.navSlideSelector).each(function(j) {
1405						
1406							$(this).css({
1407								cursor: 'pointer'
1408							});
1409							
1410							$(this).unbind(clickEvent).bind(clickEvent, function() {
1411
1412								helpers.changeSlide(j, scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1413								
1414							});
1415						
1416						});
1417								
1418					}	
1419					
1420					if(settings.navPrevSelector != '') {
1421						
1422						$(settings.navPrevSelector).css({
1423							cursor: 'pointer'
1424						});
1425						
1426						$(settings.navPrevSelector).unbind(clickEvent).bind(clickEvent, function() {	
1427						
1428							var slide = (activeChildOffsets[sliderNumber] + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
1429											
1430							if((slide > 0) || settings.infiniteSlider) {
1431								helpers.changeSlide(slide - 1, scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1432							}
1433						});
1434					
1435					}
1436					
1437					if(settings.navNextSelector != '') {
1438						
1439						$(settings.navNextSelector).css({
1440							cursor: 'pointer'
1441						});
1442						
1443						$(settings.navNextSelector).unbind(clickEvent).bind(clickEvent, function() {
1444							
1445							var slide = (activeChildOffsets[sliderNumber] + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
1446							
1447							if((slide < childrenOffsets.length-1) || settings.infiniteSlider) {

1448								helpers.changeSlide(slide + 1, scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1449							}
1450						});
1451					
1452					}
1453					
1454					if(settings.autoSlide && !shortContent) {
1455						
1456						if(settings.autoSlideToggleSelector != '') {
1457						
1458							$(settings.autoSlideToggleSelector).css({
1459								cursor: 'pointer'
1460							});
1461							
1462							$(settings.autoSlideToggleSelector).unbind(clickEvent).bind(clickEvent, function() {
1463								
1464								if(!isAutoSlideToggleOn) {
1465								
1466									helpers.autoSlidePause(sliderNumber);
1467									isAutoSlideToggleOn = true;
1468									
1469									$(settings.autoSlideToggleSelector).addClass('on');
1470									
1471								} else {
1472									
1473									helpers.autoSlide(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1474									
1475									isAutoSlideToggleOn = false;
1476									
1477									$(settings.autoSlideToggleSelector).removeClass('on');
1478									
1479								}
1480							
1481							});
1482						
1483						}
1484						
1485						if(!isAutoSlideToggleOn && !shortContent) {
1486							helpers.autoSlide(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1487						}
1488	
1489						if(!isTouch) {
1490							
1491							$(stageNode).bind('mouseenter.iosSliderEvent', function() {
1492								helpers.autoSlidePause(sliderNumber);
1493							});
1494							
1495							$(stageNode).bind('mouseleave.iosSliderEvent', function() {
1496								if(!isAutoSlideToggleOn && !shortContent) {
1497									helpers.autoSlide(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1498								}
1499							});
1500						
1501						} else {
1502							
1503							$(stageNode).bind('touchend.iosSliderEvent', function() {
1504							
1505								if(!isAutoSlideToggleOn && !shortContent) {
1506									helpers.autoSlide(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1507								}
1508							
1509							});
1510						
1511						}
1512					
1513					}
1514					
1515					$(stageNode).data('iosslider', {
1516						obj: $this,
1517						settings: settings,
1518						scrollerNode: scrollerNode,
1519						slideNodes: slideNodes,
1520						numberOfSlides: numberOfSlides,
1521						centeredSlideOffset: centeredSlideOffset,
1522						sliderNumber: sliderNumber,
1523						originalOffsets: originalOffsets,
1524						childrenOffsets: childrenOffsets,
1525						sliderMax: sliderMax[sliderNumber],
1526						scrollbarClass: scrollbarClass,
1527						scrollbarWidth: scrollbarWidth, 
1528						scrollbarStageWidth: scrollbarStageWidth,
1529						stageWidth: stageWidth, 
1530						scrollMargin: scrollMargin, 
1531						scrollBorder: scrollBorder, 
1532						infiniteSliderOffset: infiniteSliderOffset[sliderNumber], 
1533						infiniteSliderWidth: infiniteSliderWidth						
1534					});
1535					
1536					isFirstInit = false;
1537					
1538					return true;
1539				
1540				}
1541				
1542				if(iosSliderSettings[sliderNumber].responsiveSlides || iosSliderSettings[sliderNumber].responsiveSlideContainer) {
1543					
1544					var orientationEvent = supportsOrientationChange ? 'orientationchange' : 'resize';
1545					
1546					$(window).bind(orientationEvent + '.iosSliderEvent', function() {
1547							
1548						if(!init()) return true;
1549						
1550						var args = $(stageNode).data('args');
1551				
1552						if(settings.onSliderResize != '') {
1553					    	settings.onSliderResize(args);
1554					    }
1555						
1556					});
1557					
1558				}
1559				
1560				if(settings.keyboardControls && !shortContent) {
1561					
1562					$(document).bind('keydown.iosSliderEvent', function(e) {
1563						
1564						if((!isIe7) && (!isIe8)) {
1565							var e = e.originalEvent;
1566						}
1567						
1568						switch(e.keyCode) {
1569							
1570							case 37:
1571								
1572								var slide = (activeChildOffsets[sliderNumber] + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
1573
1574								if((slide > 0) || settings.infiniteSlider) {

1575									helpers.changeSlide(slide - 1, scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1576								} 
1577								
1578							break;
1579							
1580							case 39:
1581								
1582								var slide = (activeChildOffsets[sliderNumber] + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
1583								
1584								if((slide < childrenOffsets.length-1) || settings.infiniteSlider) {
1585									helpers.changeSlide(slide + 1, scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, centeredSlideOffset, settings);
1586								}
1587								
1588							break;
1589							
1590						}
1591					
1592					});
1593					
1594				}
1595					
1596				if(isTouch || settings.desktopClickDrag) {
1597					
1598					var touchStartEvent = isTouch ? 'touchstart.iosSliderEvent' : 'mousedown.iosSliderEvent';
1599					var touchSelection = $(scrollerNode);
1600					var touchSelectionMove = $(scrollerNode);
1601					var preventDefault = null;
1602					var isUnselectable = false;
1603					
1604					if(settings.scrollbarDrag) {
1605					
1606						touchSelection = touchSelection.add(scrollbarNode);
1607						touchSelectionMove = touchSelectionMove.add(scrollbarBlockNode);
1608						
1609					}
1610					
1611					$(touchSelection).bind(touchStartEvent, function(e) {
1612						
1613						if(touchLocks[sliderNumber] || shortContent) return true;
1614						
1615						isUnselectable = helpers.isUnselectable(e.target, settings);
1616						
1617						if(isUnselectable) return true;
1618						
1619						currentEventNode = ($(this)[0] === $(scrollbarNode)[0]) ? scrollbarNode : scrollerNode;
1620						
1621						if((!isIe7) && (!isIe8)) {
1622							var e = e.originalEvent;
1623						}
1624
1625						helpers.autoSlidePause(sliderNumber);
1626						
1627						allScrollerNodeChildren.unbind('.disableClick');
1628						
1629						if(!isTouch) {
1630							
1631							if (window.getSelection) {
1632								if (window.getSelection().empty) {
1633									window.getSelection().empty();
1634								} else if (window.getSelection().removeAllRanges) {
1635									window.getSelection().removeAllRanges();
1636								}
1637							} else if (document.selection) {
1638								document.selection.empty();
1639							}
1640							
1641							eventX = e.pageX;
1642							eventY = e.pageY;
1643							
1644							isMouseDown = true;
1645							currentSlider = scrollerNode;
1646
1647							$(this).css({
1648								cursor: grabInCursor
1649							});
1650							
1651						} else {
1652						
1653							eventX = e.touches[0].pageX;
1654							eventY = e.touches[0].pageY;
1655
1656						}
1657						
1658						xCurrentScrollRate = new Array(0, 0);
1659						yCurrentScrollRate = new Array(0, 0);
1660						xScrollDistance = 0;
1661						xScrollStarted = false;
1662						
1663						for(var j = 0; j < scrollTimeouts.length; j++) {
1664							clearTimeout(scrollTimeouts[j]);
1665						}
1666						
1667						var scrollPosition = helpers.getSliderOffset(scrollerNode, 'x');
1668
1669						if(scrollPosition > (sliderMin[sliderNumber] * -1 + centeredSlideOffset + scrollerWidth)) {
1670							
1671							scrollPosition = sliderMin[sliderNumber] * -1 + centeredSlideOffset + scrollerWidth;
1672
1673							helpers.setSliderOffset($('.' + scrollbarClass), scrollPosition);
1674							
1675							$('.' + scrollbarClass).css({
1676								width: (scrollbarWidth - scrollBorder) + 'px'
1677							});
1678							
1679						} else if(scrollPosition < (sliderMax[sliderNumber] * -1)) {
1680						
1681							scrollPosition = sliderMax[sliderNumber] * -1;
1682
1683							helpers.setSliderOffset($('.' + scrollbarClass), (scrollbarStageWidth - scrollMargin - scrollbarWidth));
1684							
1685							$('.' + scrollbarClass).css({
1686								width: (scrollbarWidth - scrollBorder) + 'px'
1687							});
1688							
1689						} 
1690						
1691						var scrollbarSubtractor = ($(this)[0] === $(scrollbarNode)[0]) ? (sliderMin[sliderNumber]) : 0;
1692						
1693						xScrollStartPosition = (helpers.getSliderOffset(this, 'x') - eventX - scrollbarSubtractor) * -1;
1694						yScrollStartPosition = (helpers.getSliderOffset(this, 'y') - eventY) * -1;
1695						
1696						xCurrentScrollRate[1] = eventX;
1697						yCurrentScrollRate[1] = eventY;
1698						
1699						snapOverride = false;

1700						
1701					});
1702					
1703					var touchMoveEvent = isTouch ? 'touchmove.iosSliderEvent' : 'mousemove.iosSliderEvent';
1704					
1705					$(touchSelectionMove).bind(touchMoveEvent, function(e) {
1706
1707						if((!isIe7) && (!isIe8)) {
1708							var e = e.originalEvent;
1709						}
1710						
1711						if(touchLocks[sliderNumber] || shortContent) return true;
1712						
1713						if(isUnselectable) return true;
1714						
1715						var edgeDegradation = 0;
1716
1717						if(!isTouch) {
1718							
1719							if (window.getSelection) {
1720								if (window.getSelection().empty) {
1721									window.getSelection().empty();
1722								} else if (window.getSelection().removeAllRanges) {
1723									window.getSelection().removeAllRanges();
1724								}
1725							} else if (document.selection) {
1726								document.selection.empty();
1727							}
1728							
1729						}
1730						
1731						if(isTouch) {
1732							eventX = e.touches[0].pageX;
1733							eventY = e.touches[0].pageY;
1734						} else {
1735							eventX = e.pageX;
1736							eventY = e.pageY;
1737							
1738							if(!isMouseDown) {
1739								return false;
1740							}
1741							
1742							if(!isIe) {
1743								if((typeof e.webkitMovementX != 'undefined' || typeof e.webkitMovementY != 'undefined') && e.

1743webkitMovementY === 0 && e.webkitMovementX === 0) {
1744									return false;
1745								}
1746							}
1747							
1748						}
1749						
1750						xCurrentScrollRate[0] = xCurrentScrollRate[1];
1751						xCurrentScrollRate[1] = eventX;
1752						xScrollDistance = (xCurrentScrollRate[1] - xCurrentScrollRate[0]) / 2;
1753						
1754						yCurrentScrollRate[0] = yCurrentScrollRate[1];
1755						yCurrentScrollRate[1] = eventY;
1756						yScrollDistance = (yCurrentScrollRate[1] - yCurrentScrollRate[0]) / 2;
1757						
1758						if(!xScrollStarted) {
1759						
1760							var slide = (activeChildOffsets[sliderNumber] + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
1761							var args = new helpers.args(settings, scrollerNode, $(scrollerNode).children(':eq(' + slide + ')'), slide, slide, false);
1762							$(stageNode).data('args', args);
1763
1764							if(settings.onSlideStart != '') {
1765								settings.onSlideStart(args);
1766							}
1767							
1768						}
1769						
1770						if(((yScrollDistance > 3) || (yScrollDistance < -3)) && ((xScrollDistance < 3) && (xScrollDistance > -3)) && (isTouch) && (!xScrollStarted)) {
1771							preventXScroll = true;
1772						}
1773						
1774						if(((xScrollDistance > 5) || (xScrollDistance < -5)) && (isTouch)) {
1775						
1776							e.preventDefault();
1777							xScrollStarted = true;
1778							
1779						} else if(!isTouch) {
1780							
1781							xScrollStarted = true;
1782							
1783						}
1784						
1785						if(xScrollStarted && !preventXScroll) {
1786							
1787							var scrollPosition = helpers.getSliderOffset(scrollerNode, 'x');
1788							var scrollbarSubtractor = ($(this)[0] === $(scrollbarBlockNode)[0]) ? (sliderMin[sliderNumber]) : 0;
1789							var scrollbarMultiplier = ($(this)[0] === $(scrollbarBlockNode)[0]) ? ((sliderMin[sliderNumber] - sliderMax[sliderNumber]) / (scrollbarStageWidth - scrollMargin - scrollbarWidth)) : 1;
1790							var elasticPullResistance = ($(this)[0] === $(scrollbarBlockNode)[0]) ? settings.scrollbarElasticPullResistance : settings.elasticPullResistance;
1791
1792							if(isTouch) {
1793								if(currentTouches != e.touches.length) {
1794									xScrollStartPosition = (scrollPosition * -1) + eventX;
1795								}
1796								
1797								currentTouches = e.touches.length;
1798							}
1799							
1800							if(settings.infiniteSlider) {
1801
1802								if(scrollPosition <= (sliderMax[sliderNumber] * -1)) {
1803									
1804									var scrollerWidth = $(scrollerNode).width();
1805									
1806									if(scrollPosition <= (sliderAbsMax[sliderNumber] * -1)) {
1807										
1808										var sum = originalOffsets[0] * -1;
1809										$(slideNodes).each(function(i) {
1810											
1811											helpers.setSliderOffset($(slideNodes)[i], sum + centeredSlideOffset);
1812											if(i < childrenOffsets.length) {
1813												childrenOffsets[i] = sum * -1;
1814											}
1815											sum = sum + $(this).outerWidth(true);
1816											
1817										});
1818										
1819										xScrollStartPosition = xScrollStartPosition - childrenOffsets[0] * -1;
1820										sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
1821										sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
1822										infiniteSliderOffset[sliderNumber] = 0;
1823										
1824									} else {
1825										
1826										var lowSlideNumber = 0;
1827										var lowSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
1828										$(slideNodes).each(function(i) {
1829											
1830											if(helpers.getSliderOffset(this, 'x') < lowSlideOffset) {
1831												lowSlideOffset = helpers.getSliderOffset(this, 'x');
1832												lowSlideNumber = i;
1833											}
1834											
1835										});
1836										
1837										var newOffset = sliderMin[sliderNumber] + scrollerWidth;
1838										helpers.setSliderOffset($(slideNodes)[lowSlideNumber], newOffset);
1839										
1840										sliderMin[sliderNumber] = childrenOffsets[1] * -1 + centeredSlideOffset;
1841										sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
1842
1843										childrenOffsets.splice(0, 1);
1844										childrenOffsets.splice(childrenOffsets.length, 0, newOffset * -1 + centeredSlideOffset);
1845
1846										infiniteSliderOffset[sliderNumber]++;
1847										
1848									}
1849									
1850								}
1851								
1852								if((scrollPosition >= (sliderMin[sliderNumber] * -1)) || (scrollPosition >= 0)) {
1853		
1854									var scrollerWidth = $(scrollerNode).width();
1855									
1856									if(scrollPosition >= 0) {
1857									
1858										var sum = originalOffsets[0] * -1;
1859										$(slideNodes).each(function(i) {
1860											
1861											helpers.setSliderOffset($(slideNodes)[i], sum + centeredSlideOffset);
1862											if(i < childrenOffsets.length) {
1863												childrenOffsets[i] = sum * -1;
1864											}
1865											sum = sum + $(this).outerWidth(true);
1866											
1867										});
1868										
1869										xScrollStartPosition = xScrollStartPosition + childrenOffsets[0] * -1;
1870										sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
1871										sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
1872										infiniteSliderOffset[sliderNumber] = numberOfSlides;
1873										
1874										while(((childrenOffsets[0] * -1 - scrollerWidth + centeredSlideOffset) > 0)) {
1875				
1876											var highSlideNumber = 0;
1877											var highSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
1878											$(slideNodes).each(function(i) {
1879												
1880												if(helpers.getSliderOffset(this, 'x') > highSlideOffset) {
1881													highSlideOffset = helpers.getSliderOffset(this, 'x');
1882													highSlideNumber = i;
1883												}
1884												
1885											});
1886				
1887											var newOffset = sliderMin[sliderNumber] - $(slideNodes[highSlideNumber]).outerWidth(true);
1888											helpers.setSliderOffset($(slideNodes)[highSlideNumber], newOffset);
1889											
1890											childrenOffsets.splice(0, 0, newOffset * -1 + centeredSlideOffset);
1891											childrenOffsets.splice(childrenOffsets.length-1, 1);
1892				
1893											sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
1894											sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
1895				
1896											infiniteSliderOffset[sliderNumber]--;
1897											activeChildOffsets[sliderNumber]++;
1898											
1899										}
1900
1901									} else {
1902
1903										var highSlideNumber = 0;
1904										var highSlideOffset = helpers.getSliderOffset($(slideNodes[0]), 'x');
1905										$(slideNodes).each(function(i) {
1906											
1907											if(helpers.getSliderOffset(this, 'x') > highSlideOffset) {
1908												highSlideOffset = helpers.getSliderOffset(this, 'x');
1909												highSlideNumber = i;
1910											}
1911											
1912										});
1913										
1914										var newOffset = sliderMin[sliderNumber] - $(slideNodes[highSlideNumber]).outerWidth(true);
1915										helpers.setSliderOffset($(slideNodes)[highSlideNumber], newOffset);									
1916										
1917										childrenOffsets.splice(0, 0, newOffset * -1 + centeredSlideOffset);
1918										childrenOffsets.splice(childrenOffsets.length-1, 1);
1919
1920										sliderMin[sliderNumber] = childrenOffsets[0] * -1 + centeredSlideOffset;
1921										sliderMax[sliderNumber] = sliderMin[sliderNumber] + scrollerWidth - stageWidth;
1922
1923										infiniteSliderOffset[sliderNumber]--;
1924
1925									}
1926								
1927								}
1928								
1929							} else {
1930								
1931								var scrollerWidth = $(scrollerNode).width();
1932								
1933								if(scrollPosition > (sliderMin[sliderNumber] * -1 + centeredSlideOffset)) {
1934
1935									edgeDegradation = (sliderMin[sliderNumber] + ((xScrollStartPosition - scrollbarSubtractor - eventX + centeredSlideOffset) * -1 * scrollbarMultiplier) - scrollbarSubtractor) * elasticPullResistance * -1 / scrollbarMultiplier;
1936									
1937								}
1938								
1939								if(scrollPosition < (sliderMax[sliderNumber] * -1)) {
1940									
1941									edgeDegradation = (sliderMax[sliderNumber] + ((xScrollStartPosition - scrollbarSubtractor - eventX) * -1 * scrollbarMultiplier) - scrollbarSubtractor) * elasticPullResistance * -1 / scrollbarMultiplier;
1942												
1943								}
1944							
1945							}
1946
1947							helpers.setSliderOffset(scrollerNode, ((xScrollStartPosition - scrollbarSubtractor - eventX - edgeDegradation) * -1 * scrollbarMultiplier) - scrollbarSubtractor);
1948
1949							if(settings.scrollbar) {
1950								
1951								helpers.showScrollbar(settings, scrollbarClass);
1952
1953								scrollbarDistance = Math.floor((xScrollStartPosition - eventX - edgeDegradation - sliderMin[sliderNumber] + centeredSlideOffset) / (sliderMax[sliderNumber] - sliderMin[sliderNumber]) * (scrollbarStageWidth - scrollMargin - scrollbarWidth) * scrollbarMultiplier);
1954								
1955								var width = scrollbarWidth;
1956								
1957								if(scrollPosition >= (sliderMin[sliderNumber] * -1 + centeredSlideOffset + scrollerWidth)) {
1958
1959									width = scrollbarWidth - scrollBorder - (scrollbarDistance * -1);
1960									
1961									helpers.setSliderOffset($('.' + scrollbarClass), 0);
1962									
1963									$('.' + scrollbarClass).css({
1964										width: width + 'px'
1965									});
1966									
1967								} else if(scrollPosition <= ((sliderMax[sliderNumber] * -1) + 1)) {
1968																		
1969									width = scrollbarStageWidth - scrollMargin - scrollBorder - scrollbarDistance;
1970									
1971									helpers.setSliderOffset($('.' + scrollbarClass), scrollbarDistance);
1972									
1973									$('.' + scrollbarClass).css({
1974										width: width + 'px'
1975									});
1976									
1977								} else {
1978
1979									helpers.setSliderOffset($('.' + scrollbarClass), scrollbarDistance);
1980									
1981								}
1982								
1983							}
1984							
1985							if(isTouch) {
1986								lastTouch = e.touches[0].pageX;
1987							}
1988
1989							var slideChanged = false;

1990							var newChildOffset = helpers.calcActiveOffset(settings, (xScrollStartPosition - eventX - edgeDegradation) * -1, childrenOffsets, stageWidth, infiniteSliderOffset[sliderNumber], numberOfSlides, undefined, sliderNumber);
1991							var tempOffset = (newChildOffset + infiniteSliderOffset[sliderNumber] + numberOfSlides)%numberOfSlides;
1992
1993							if(settings.infiniteSlider) {
1994								
1995								if(tempOffset != activeChildInfOffsets[sliderNumber]) {
1996									slideChanged = true;
1997								}
1998									
1999							} else {
2000							
2001								if(newChildOffset != activeChildOffsets[sliderNumber]) {
2002									slideChanged = true;
2003								}
2004							
2005							}
2006							
2007							if(slideChanged) {
2008								
2009								activeChildOffsets[sliderNumber] = newChildOffset;
2010								activeChildInfOffsets[sliderNumber] = tempOffset;
2011								snapOverride = true;
2012								
2013								var args = new helpers.args(settings, scrollerNode, $(scrollerNode).children(':eq(' + tempOffset + ')'), tempOffset, tempOffset, true);
2014								$(stageNode).data('args', args);
2015								
2016								if(settings.onSlideChange != '') {
2017									settings.onSlideChange(args);
2018								}
2019								
2020							}
2021							
2022						}
2023						
2024					});
2025					
2026					$(touchSelection).bind('touchend.iosSliderEvent', function(e) {
2027						
2028						var e = e.originalEvent;
2029						
2030						if(touchLocks[sliderNumber] || shortContent) return true;
2031						
2032						if(isUnselectable) return true;
2033						
2034						if(e.touches.length != 0) {
2035							
2036							for(var j = 0; j < e.touches.length; j++) {
2037								
2038								if(e.touches[j].pageX == lastTouch) {
2039									helpers.slowScrollHorizontal(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, xScrollDistance, yScrollDistance, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, currentEventNode, snapOverride, centeredSlideOffset, settings);
2040								}
2041								
2042							}
2043							
2044						} else {
2045							
2046							helpers.slowScrollHorizontal(scrollerNode, slideNodes, scrollTimeouts, scrollbarClass, xScrollDistance, yScrollDistance, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, currentEventNode, snapOverride, centeredSlideOffset, settings);
2047							
2048						}
2049						
2050						preventXScroll = false;
2051						
2052					});
2053					
2054					if(!isTouch) {
2055
2056						var eventObject = $(window);
2057	
2058						if(isIe8 || isIe7) {
2059							var eventObject = $(document); 
2060						}
2061						
2062						$(eventObject).bind('mouseup.iosSliderEvent' + sliderNumber, function(e) {
2063							
2064							if(xScrollStarted) {
2065								anchorEvents.unbind('click.disableClick').bind('click.disableClick', helpers.preventClick);
2066							} else {
2067								anchorEvents.unbind('click.disableClick').bind('click.disableClick', helpers.enableClick);
2068							}
2069							
2070							onclickEvents.each(function() {
2071								
2072								this.onclick = function(event) {
2073									if(xScrollStarted) { 
2074										return false;
2075									}
2076								
2077									$(this).data('onclick').call(this, event || window.event);
2078								}
2079								
2080							});
2081							
2082							if(parseFloat($().jquery) >= 1.8) {
2083								
2084								allScrollerNodeChildren.each(function() {
2085										
2086									var clickObject = $._data(this, 'events');
2087									
2088									if(clickObject != undefined) {
2089										if(clickObject.click != undefined) {
2090
2091											if(clickObject.click[0].namespace != 'iosSliderEvent') {
2092												
2093												if(!xScrollStarted) { 
2094													return false;
2095												}
2096											
2097												$(this).one('click.disableClick', helpers.preventClick);
2098											    var handlers = $._data(this, 'events').click;
2099											    var handler = handlers.pop();
2100											    handlers.splice(0, 0, handler);
2101												
2102											}
2103											
2104										}
2105									}
2106									
2107								});
2108							
2109							} else if(parseFloat($().jquery) >= 1.6) {
2110							
2111								allScrollerNodeChildren.each(function() {
2112										
2113									var clickObject = $(this).data('events');
2114									
2115									if(clickObject != undefined) {
2116										if(clickObject.click != undefined) {
2117
2118											if(clickObject.click[0].namespace != 'iosSliderEvent') {
2119												
2120												if(!xScrollStarted) { 
2121													return false;

2122												}
2123											
2124												$(this).one('click.disableClick', helpers.preventClick);
2125											    var handlers = $(this).data('events').click;
2126											    var handler = handlers.pop();
2127											    handlers.splice(0, 0, handler);
2128												
2129											}
2130											
2131										}
2132									}
2133									
2134								});
2135							
2136							} else {
2137							}
2138							
2139							if(!isEventCleared[sliderNumber]) {
2140							
2141								if(shortContent) return true;
2142								
2143								$(touchSelection).css({
2144									cursor: grabOutCursor
2145								});
2146								
2147								isMouseDown = false;
2148								
2149								if(currentSlider == undefined) {
2150									return false;
2151								}
2152
2153								helpers.slowScrollHorizontal(currentSlider, slideNodes, scrollTimeouts, scrollbarClass, xScrollDistance, yScrollDistance, scrollbarWidth, stageWidth, scrollbarStageWidth, scrollMargin, scrollBorder, originalOffsets, childrenOffsets, sliderNumber, infiniteSliderWidth, numberOfSlides, currentEventNode, snapOverride, centeredSlideOffset, settings);
2154								
2155								currentSlider = undefined;
2156							
2157							}
2158							
2159							preventXScroll = false;
2160							
2161						});
2162						
2163					} 
2164				
2165				}
2166				
2167			});	
2168			
2169		},
2170		
2171		
2172		lock: function() {
2173			
2174			return this.each(function() {
2175			
2176				var $this = $(this);
2177				var data = $this.data('iosslider');
2178				if(data == undefined) return false;
2179
2180				touchLocks[data.sliderNumber] = true;
2181			
2182			});
2183			
2184		},
2185		
2186		unlock: function() {
2187		
2188			return this.each(function() {
2189			
2190				var $this = $(this);
2191				var data = $this.data('iosslider');
2192				if(data == undefined) return false;
2193
2194				touchLocks[data.sliderNumber] = false;
2195			
2196			});
2197		
2198		},
2199		
2200		getData: function() {
2201		
2202			return this.each(function() {
2203			
2204				var $this = $(this);
2205				var data = $this.data('iosslider');
2206				if(data == undefined) return false;
2207				
2208				return data;
2209			
2210			});	
2211		
2212		}
2213		
2214	
2215	}
2216	
2217	/* public functions */
2218	$.fn.iosSlider = function(method) {
2219
2220		if(methods[method]) {
2221			return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
2222		} else if (typeof method === 'object' || !method) {
2223			return methods.init.apply(this, arguments);
2224		} else {
2225			$.error('invalid method call!');
2226		}
2227	
2228    };
2229
2230}) (jQuery);
2231
2232