/*!
* jScrollPane - v2.0.0beta11 - 2011-07-04
* http://jscrollpane.kelvinluck.com/
*
* Copyright (c) 2010 Kelvin Luck
* Dual licensed under the MIT and GPL licenses.
*/

// Script: jScrollPane - cross browser customisable scrollbars
//
// *Version: 2.0.0beta11, Last updated: 2011-07-04*
//
// Project Home - http://jscrollpane.kelvinluck.com/
// GitHub       - http://github.com/vitch/jScrollPane
// Source       - http://github.com/vitch/jScrollPane/raw/master/script/jquery.jscrollpane.js
// (Minified)   - http://github.com/vitch/jScrollPane/raw/master/script/jquery.jscrollpane.min.js
//
// About: License
//
// Copyright (c) 2011 Kelvin Luck
// Dual licensed under the MIT or GPL Version 2 licenses.
// http://jscrollpane.kelvinluck.com/MIT-LICENSE.txt
// http://jscrollpane.kelvinluck.com/GPL-LICENSE.txt
//
// About: Examples
//
// All examples and demos are available through the jScrollPane example site at:
// http://jscrollpane.kelvinluck.com/
//
// About: Support and Testing
//
// This plugin is tested on the browsers below and has been found to work reliably on them. If you run
// into a problem on one of the supported browsers then please visit the support section on the jScrollPane
// website (http://jscrollpane.kelvinluck.com/) for more information on getting support. You are also
// welcome to fork the project on GitHub if you can contribute a fix for a given issue.
//
// jQuery Versions - tested in 1.4.2+ - reported to work in 1.3.x
// Browsers Tested - Firefox 3.6.8, Safari 5, Opera 10.6, Chrome 5.0, IE 6, 7, 8
//
// About: Release History
//
// 2.0.0beta11 - (in progress)
// 2.0.0beta10 - (2011-04-17) cleaner required size calculation, improved keyboard support, stickToBottom/Left, other small fixes
// 2.0.0beta9 - (2011-01-31) new API methods, bug fixes and correct keyboard support for FF/OSX
// 2.0.0beta8 - (2011-01-29) touchscreen support, improved keyboard support
// 2.0.0beta7 - (2011-01-23) scroll speed consistent (thanks Aivo Paas)
// 2.0.0beta6 - (2010-12-07) scrollToElement horizontal support
// 2.0.0beta5 - (2010-10-18) jQuery 1.4.3 support, various bug fixes
// 2.0.0beta4 - (2010-09-17) clickOnTrack support, bug fixes
// 2.0.0beta3 - (2010-08-27) Horizontal mousewheel, mwheelIntent, keyboard support, bug fixes
// 2.0.0beta2 - (2010-08-21) Bug fixes
// 2.0.0beta1 - (2010-08-17) Rewrite to follow modern best practices and enable horizontal scrolling, initially hidden
//							 elements and dynamically sized elements.
// 1.x - (2006-12-31 - 2010-07-31) Initial version, hosted at googlecode, deprecated

(function($, window, undefined) {

	$.fn.jScrollPane = function(settings) {
		// JScrollPane "class" - public methods are available through $('selector').data('jsp')
		function JScrollPane(elem, s) {
			var settings, jsp = this, pane, paneWidth, paneHeight, container, contentWidth, contentHeight, percentInViewH, percentInViewV, isScrollableV, isScrollableH, verticalDrag, dragMaxY, verticalDragPosition, horizontalDrag, dragMaxX, horizontalDragPosition, verticalBar, verticalTrack, scrollbarWidth, verticalTrackHeight, verticalDragHeight, arrowUp, arrowDown, horizontalBar, horizontalTrack, horizontalTrackWidth, horizontalDragWidth, arrowLeft, arrowRight, reinitialiseInterval, originalPadding, originalPaddingTotalWidth, previousContentWidth, wasAtTop = true, wasAtLeft = true, wasAtBottom = false, wasAtRight = false, originalElement = elem.clone(false, false).empty(), mwEvent = $.fn.mwheelIntent ? 'mwheelIntent.jsp' : 'mousewheel.jsp';
			originalPadding = elem.css('paddingTop') + ' ' + elem.css('paddingRight') + ' ' + elem.css('paddingBottom') + ' ' + elem.css('paddingLeft');
			originalPaddingTotalWidth = (parseInt(elem.css('paddingLeft'), 10) || 0) + (parseInt(elem.css('paddingRight'), 10) || 0);

			function initialise(s) {

				var/*firstChild, lastChild, */
				isMaintainingPositon, lastContentX, lastContentY, hasContainingSpaceChanged, originalScrollTop, originalScrollLeft, maintainAtBottom = false, maintainAtRight = false;
				settings = s;

				if(pane === undefined) {
					originalScrollTop = elem.scrollTop();
					originalScrollLeft = elem.scrollLeft();

					elem.css({
						overflow : 'hidden',
						padding : 0
					});
					// TODO: Deal with where width/ height is 0 as it probably means the element is hidden and we should
					// come back to it later and check once it is unhidden...
					paneWidth = elem.innerWidth() + originalPaddingTotalWidth;
					paneHeight = elem.innerHeight();

					elem.width(paneWidth);
					pane = $('<div class="jspPane" />').css('padding', originalPadding).append(elem.children());
					container = $('<div class="jspContainer" />').css({
						'width' : paneWidth + 'px',
						'height' : paneHeight + 'px'
					}).append(pane).appendTo(elem);

					/*
					 // Move any margins from the first and last children up to the container so they can still
					 // collapse with neighbouring elements as they would before jScrollPane
					 firstChild = pane.find(':first-child');
					 lastChild = pane.find(':last-child');
					 elem.css(
					 {
					 'margin-top': firstChild.css('margin-top'),
					 'margin-bottom': lastChild.css('margin-bottom')
					 }
					 );
					 firstChild.css('margin-top', 0);
					 lastChild.css('margin-bottom', 0);
					 */
				} else {
					elem.css('width', '');
					maintainAtBottom = settings.stickToBottom && isCloseToBottom();
					maintainAtRight = settings.stickToRight && isCloseToRight();
					hasContainingSpaceChanged = elem.innerWidth() + originalPaddingTotalWidth != paneWidth || elem.outerHeight() != paneHeight;

					if(hasContainingSpaceChanged) {
						paneWidth = elem.innerWidth() + originalPaddingTotalWidth;
						paneHeight = elem.innerHeight();
						container.css({
							width : paneWidth + 'px',
							height : paneHeight + 'px'
						});
					}

					// If nothing changed since last check...
					if(!hasContainingSpaceChanged && previousContentWidth == contentWidth && pane.outerHeight() == contentHeight) {
						elem.width(paneWidth);
						return;
					}
					previousContentWidth = contentWidth;

					pane.css('width', '');
					elem.width(paneWidth);

					container.find('>.jspVerticalBar,>.jspHorizontalBar').remove().end();
				}

				pane.css('overflow', 'auto');
				if(s.contentWidth) {
					contentWidth = s.contentWidth;
				} else {
					contentWidth = pane[0].scrollWidth;
				}
				contentHeight = pane[0].scrollHeight;
				pane.css('overflow', '');
				percentInViewH = contentWidth / paneWidth;
				percentInViewV = contentHeight / paneHeight;
				isScrollableV = percentInViewV > 1;
				isScrollableH = percentInViewH > 1;

				//console.log(paneWidth, paneHeight, contentWidth, contentHeight, percentInViewH, percentInViewV, isScrollableH, isScrollableV);

				if(!(isScrollableH || isScrollableV)) {
					elem.removeClass('jspScrollable');
					pane.css({
						top : 0,
						width : container.width() - originalPaddingTotalWidth
					});
					removeMousewheel();
					removeFocusHandler();
					removeKeyboardNav();
					removeClickOnTrack();
					unhijackInternalLinks();
				} else {
					elem.addClass('jspScrollable');
					isMaintainingPositon = settings.maintainPosition && (verticalDragPosition || horizontalDragPosition);
					if(isMaintainingPositon) {
						lastContentX = contentPositionX();
						lastContentY = contentPositionY();
					}

					initialiseVerticalScroll();
					initialiseHorizontalScroll();
					resizeScrollbars();

					if(isMaintainingPositon) {
						scrollToX( maintainAtRight ? (contentWidth - paneWidth ) : lastContentX, false);
						scrollToY( maintainAtBottom ? (contentHeight - paneHeight) : lastContentY, false);
					}

					initFocusHandler();
					initMousewheel();
					initTouch();

					if(settings.enableKeyboardNavigation) {
						initKeyboardNav();
					}
					if(settings.clickOnTrack) {
						initClickOnTrack();
					}

					observeHash();
					if(settings.hijackInternalLinks) {
						hijackInternalLinks();
					}
				}

				if(settings.autoReinitialise && !reinitialiseInterval) {
					reinitialiseInterval = setInterval(function() {
						initialise(settings);
					}, settings.autoReinitialiseDelay);
				} else if(!settings.autoReinitialise && reinitialiseInterval) {
					clearInterval(reinitialiseInterval);
				}
				originalScrollTop && elem.scrollTop(0) && scrollToY(originalScrollTop, false); originalScrollLeft && elem.scrollLeft(0) && scrollToX(originalScrollLeft, false);

				elem.trigger('jsp-initialised', [isScrollableH || isScrollableV]);
			}

			function initialiseVerticalScroll() {
				if(isScrollableV) {

					container.append($('<div class="jspVerticalBar" />').append($('<div class="jspCap jspCapTop" />'), $('<div class="jspTrack" />').append($('<div class="jspDrag" />').append($('<div class="jspDragTop" />'), $('<div class="jspDragBottom" />'))), $('<div class="jspCap jspCapBottom" />')));
					verticalBar = container.find('>.jspVerticalBar');
					verticalTrack = verticalBar.find('>.jspTrack');
					verticalDrag = verticalTrack.find('>.jspDrag');

					if(settings.showArrows) {
						arrowUp = $('<a class="jspArrow jspArrowUp" />').bind('mousedown.jsp', getArrowScroll(0, -1)).bind('click.jsp', nil);
						arrowDown = $('<a class="jspArrow jspArrowDown" />').bind('mousedown.jsp', getArrowScroll(0, 1)).bind('click.jsp', nil);
						if(settings.arrowScrollOnHover) {
							arrowUp.bind('mouseover.jsp', getArrowScroll(0, -1, arrowUp));
							arrowDown.bind('mouseover.jsp', getArrowScroll(0, 1, arrowDown));
						}

						appendArrows(verticalTrack, settings.verticalArrowPositions, arrowUp, arrowDown);
					}
					verticalTrackHeight = paneHeight;
					container.find('>.jspVerticalBar>.jspCap:visible,>.jspVerticalBar>.jspArrow').each(function() {
						verticalTrackHeight -= $(this).outerHeight();
					});

					verticalDrag.hover(function() {
						verticalDrag.addClass('jspHover');
					}, function() {
						verticalDrag.removeClass('jspHover');
					}).bind('mousedown.jsp', function(e) {
						// Stop IE from allowing text selection
						$('html').bind('dragstart.jsp selectstart.jsp', nil);

						verticalDrag.addClass('jspActive');

						var startY = e.pageY - verticalDrag.position().top;

						$('html').bind('mousemove.jsp', function(e) {
							positionDragY(e.pageY - startY, false);
						}).bind('mouseup.jsp mouseleave.jsp', cancelDrag);
						return false;
					});
					sizeVerticalScrollbar();
				}
			}

			function sizeVerticalScrollbar() {
				verticalTrack.height(verticalTrackHeight + 'px');
				verticalDragPosition = 0;
				scrollbarWidth = settings.verticalGutter + verticalTrack.outerWidth();

				// Make the pane thinner to allow for the vertical scrollbar
				pane.width(paneWidth - scrollbarWidth - originalPaddingTotalWidth);

				// Add margin to the left of the pane if scrollbars are on that side (to position
				// the scrollbar on the left or right set it's left or right property in CSS)
				try {
					if(verticalBar.position().left === 0) {
						pane.css('margin-left', scrollbarWidth + 'px');
					}
				} catch (err) {
				}
			}

			function initialiseHorizontalScroll() {
				if(isScrollableH) {

					container.append($('<div class="jspHorizontalBar" />').append($('<div class="jspCap jspCapLeft" />'), $('<div class="jspTrack" />').append($('<div class="jspDrag" />').append($('<div class="jspDragLeft" />'), $('<div class="jspDragRight" />'))), $('<div class="jspCap jspCapRight" />')));
					horizontalBar = container.find('>.jspHorizontalBar');
					horizontalTrack = horizontalBar.find('>.jspTrack');
					horizontalDrag = horizontalTrack.find('>.jspDrag');

					if(settings.showArrows) {
						arrowLeft = $('<a class="jspArrow jspArrowLeft" />').bind('mousedown.jsp', getArrowScroll(-1, 0)).bind('click.jsp', nil);
						arrowRight = $('<a class="jspArrow jspArrowRight" />').bind('mousedown.jsp', getArrowScroll(1, 0)).bind('click.jsp', nil);
						if(settings.arrowScrollOnHover) {
							arrowLeft.bind('mouseover.jsp', getArrowScroll(-1, 0, arrowLeft));
							arrowRight.bind('mouseover.jsp', getArrowScroll(1, 0, arrowRight));
						}
						appendArrows(horizontalTrack, settings.horizontalArrowPositions, arrowLeft, arrowRight);
					}

					horizontalDrag.hover(function() {
						horizontalDrag.addClass('jspHover');
					}, function() {
						horizontalDrag.removeClass('jspHover');
					}).bind('mousedown.jsp', function(e) {
						// Stop IE from allowing text selection
						$('html').bind('dragstart.jsp selectstart.jsp', nil);

						horizontalDrag.addClass('jspActive');

						var startX = e.pageX - horizontalDrag.position().left;

						$('html').bind('mousemove.jsp', function(e) {
							positionDragX(e.pageX - startX, false);
						}).bind('mouseup.jsp mouseleave.jsp', cancelDrag);
						return false;
					});
					horizontalTrackWidth = container.innerWidth();
					sizeHorizontalScrollbar();
				}
			}

			function sizeHorizontalScrollbar() {
				container.find('>.jspHorizontalBar>.jspCap:visible,>.jspHorizontalBar>.jspArrow').each(function() {
					horizontalTrackWidth -= $(this).outerWidth();
				});

				horizontalTrack.width(horizontalTrackWidth + 'px');
				horizontalDragPosition = 0;
			}

			function resizeScrollbars() {
				if(isScrollableH && isScrollableV) {
					var horizontalTrackHeight = horizontalTrack.outerHeight(), verticalTrackWidth = verticalTrack.outerWidth();
					verticalTrackHeight -= horizontalTrackHeight;
					$(horizontalBar).find('>.jspCap:visible,>.jspArrow').each(function() {
						horizontalTrackWidth += $(this).outerWidth();
					});
					horizontalTrackWidth -= verticalTrackWidth;
					paneHeight -= verticalTrackWidth;
					paneWidth -= horizontalTrackHeight;
					horizontalTrack.parent().append($('<div class="jspCorner" />').css('width', horizontalTrackHeight + 'px'));
					sizeVerticalScrollbar();
					sizeHorizontalScrollbar();
				}
				// reflow content
				if(isScrollableH) {
					pane.width((container.outerWidth() - originalPaddingTotalWidth) + 'px');
				}
				contentHeight = pane.outerHeight();
				percentInViewV = contentHeight / paneHeight;

				if(isScrollableH) {
					horizontalDragWidth = Math.ceil(1 / percentInViewH * horizontalTrackWidth);
					if(horizontalDragWidth > settings.horizontalDragMaxWidth) {
						horizontalDragWidth = settings.horizontalDragMaxWidth;
					} else if(horizontalDragWidth < settings.horizontalDragMinWidth) {
						horizontalDragWidth = settings.horizontalDragMinWidth;
					}
					horizontalDrag.width(horizontalDragWidth + 'px');
					dragMaxX = horizontalTrackWidth - horizontalDragWidth;
					_positionDragX(horizontalDragPosition);
					// To update the state for the arrow buttons
				}
				if(isScrollableV) {
					verticalDragHeight = Math.ceil(1 / percentInViewV * verticalTrackHeight);
					if(verticalDragHeight > settings.verticalDragMaxHeight) {
						verticalDragHeight = settings.verticalDragMaxHeight;
					} else if(verticalDragHeight < settings.verticalDragMinHeight) {
						verticalDragHeight = settings.verticalDragMinHeight;
					}
					verticalDrag.height(verticalDragHeight + 'px');
					dragMaxY = verticalTrackHeight - verticalDragHeight;
					_positionDragY(verticalDragPosition);
					// To update the state for the arrow buttons
				}
			}

			function appendArrows(ele, p, a1, a2) {
				var p1 = "before", p2 = "after", aTemp;

				// Sniff for mac... Is there a better way to determine whether the arrows would naturally appear
				// at the top or the bottom of the bar?
				if(p == "os") {
					p = /Mac/.test(navigator.platform) ? "after" : "split";
				}
				if(p == p1) {
					p2 = p;
				} else if(p == p2) {
					p1 = p;
					aTemp = a1;
					a1 = a2;
					a2 = aTemp;
				}

				ele[p1](a1)[p2](a2);
			}

			function getArrowScroll(dirX, dirY, ele) {
				return function() {
					arrowScroll(dirX, dirY, this, ele);
					this.blur();
					return false;
				};
			}

			function arrowScroll(dirX, dirY, arrow, ele) {
				arrow = $(arrow).addClass('jspActive');

				var eve, scrollTimeout, isFirst = true, doScroll = function() {
					if(dirX !== 0) {
						jsp.scrollByX(dirX * settings.arrowButtonSpeed);
					}
					if(dirY !== 0) {
						jsp.scrollByY(dirY * settings.arrowButtonSpeed);
					}
					scrollTimeout = setTimeout(doScroll, isFirst ? settings.initialDelay : settings.arrowRepeatFreq);
					isFirst = false;
				};
				doScroll();
				eve = ele ? 'mouseout.jsp' : 'mouseup.jsp';
				ele = ele || $('html');
				ele.bind(eve, function() {
					arrow.removeClass('jspActive');
					scrollTimeout && clearTimeout(scrollTimeout);
					scrollTimeout = null;
					ele.unbind(eve);
				});
			}

			function initClickOnTrack() {
				removeClickOnTrack();
				if(isScrollableV) {
					verticalTrack.bind('mousedown.jsp', function(e) {
						if(e.originalTarget === undefined || e.originalTarget == e.currentTarget) {
							var clickedTrack = $(this), offset = clickedTrack.offset(), direction = e.pageY - offset.top - verticalDragPosition, scrollTimeout, isFirst = true, doScroll = function() {
								var offset = clickedTrack.offset(), pos = e.pageY - offset.top - verticalDragHeight / 2, contentDragY = paneHeight * settings.scrollPagePercent, dragY = dragMaxY * contentDragY / (contentHeight - paneHeight);
								if(direction < 0) {
									if(verticalDragPosition - dragY > pos) {
										jsp.scrollByY(-contentDragY);
									} else {
										positionDragY(pos);
									}
								} else if(direction > 0) {
									if(verticalDragPosition + dragY < pos) {
										jsp.scrollByY(contentDragY);
									} else {
										positionDragY(pos);
									}
								} else {
									cancelClick();
									return;
								}
								scrollTimeout = setTimeout(doScroll, isFirst ? settings.initialDelay : settings.trackClickRepeatFreq);
								isFirst = false;
							}, cancelClick = function() {
								scrollTimeout && clearTimeout(scrollTimeout);
								scrollTimeout = null;
								$(document).unbind('mouseup.jsp', cancelClick);
							};
							doScroll();
							$(document).bind('mouseup.jsp', cancelClick);
							return false;
						}
					});
				}

				if(isScrollableH) {
					horizontalTrack.bind('mousedown.jsp', function(e) {
						if(e.originalTarget === undefined || e.originalTarget == e.currentTarget) {
							var clickedTrack = $(this), offset = clickedTrack.offset(), direction = e.pageX - offset.left - horizontalDragPosition, scrollTimeout, isFirst = true, doScroll = function() {
								var offset = clickedTrack.offset(), pos = e.pageX - offset.left - horizontalDragWidth / 2, contentDragX = paneWidth * settings.scrollPagePercent, dragX = dragMaxX * contentDragX / (contentWidth - paneWidth);
								if(direction < 0) {
									if(horizontalDragPosition - dragX > pos) {
										jsp.scrollByX(-contentDragX);
									} else {
										positionDragX(pos);
									}
								} else if(direction > 0) {
									if(horizontalDragPosition + dragX < pos) {
										jsp.scrollByX(contentDragX);
									} else {
										positionDragX(pos);
									}
								} else {
									cancelClick();
									return;
								}
								scrollTimeout = setTimeout(doScroll, isFirst ? settings.initialDelay : settings.trackClickRepeatFreq);
								isFirst = false;
							}, cancelClick = function() {
								scrollTimeout && clearTimeout(scrollTimeout);
								scrollTimeout = null;
								$(document).unbind('mouseup.jsp', cancelClick);
							};
							doScroll();
							$(document).bind('mouseup.jsp', cancelClick);
							return false;
						}
					});
				}
			}

			function removeClickOnTrack() {
				if(horizontalTrack) {
					horizontalTrack.unbind('mousedown.jsp');
				}
				if(verticalTrack) {
					verticalTrack.unbind('mousedown.jsp');
				}
			}

			function cancelDrag() {
				$('html').unbind('dragstart.jsp selectstart.jsp mousemove.jsp mouseup.jsp mouseleave.jsp');

				if(verticalDrag) {
					verticalDrag.removeClass('jspActive');
				}
				if(horizontalDrag) {
					horizontalDrag.removeClass('jspActive');
				}
			}

			function positionDragY(destY, animate) {
				if(!isScrollableV) {
					return;
				}
				if(destY < 0) {
					destY = 0;
				} else if(destY > dragMaxY) {
					destY = dragMaxY;
				}

				// can't just check if(animate) because false is a valid value that could be passed in...
				if(animate === undefined) {
					animate = settings.animateScroll;
				}
				if(animate) {
					jsp.animate(verticalDrag, 'top', destY, _positionDragY);
				} else {
					verticalDrag.css('top', destY);
					_positionDragY(destY);
				}

			}

			function _positionDragY(destY) {
				if(destY === undefined) {
					destY = verticalDrag.position().top;
				}

				container.scrollTop(0);
				verticalDragPosition = destY;

				var isAtTop = verticalDragPosition === 0, isAtBottom = verticalDragPosition == dragMaxY, percentScrolled = destY / dragMaxY, destTop = -percentScrolled * (contentHeight - paneHeight);

				if(wasAtTop != isAtTop || wasAtBottom != isAtBottom) {
					wasAtTop = isAtTop;
					wasAtBottom = isAtBottom;
					elem.trigger('jsp-arrow-change', [wasAtTop, wasAtBottom, wasAtLeft, wasAtRight]);
				}

				updateVerticalArrows(isAtTop, isAtBottom);
				pane.css('top', destTop);
				elem.trigger('jsp-scroll-y', [-destTop, isAtTop, isAtBottom]).trigger('scroll');
			}

			function positionDragX(destX, animate) {
				if(!isScrollableH) {
					return;
				}
				if(destX < 0) {
					destX = 0;
				} else if(destX > dragMaxX) {
					destX = dragMaxX;
				}

				if(animate === undefined) {
					animate = settings.animateScroll;
				}
				if(animate) {
					jsp.animate(horizontalDrag, 'left', destX, _positionDragX);
				} else {
					horizontalDrag.css('left', destX);
					_positionDragX(destX);
				}
			}

			function _positionDragX(destX) {
				if(destX === undefined) {
					destX = horizontalDrag.position().left;
				}

				container.scrollTop(0);
				horizontalDragPosition = destX;

				var isAtLeft = horizontalDragPosition === 0, isAtRight = horizontalDragPosition == dragMaxX, percentScrolled = destX / dragMaxX, destLeft = -percentScrolled * (contentWidth - paneWidth);

				if(wasAtLeft != isAtLeft || wasAtRight != isAtRight) {
					wasAtLeft = isAtLeft;
					wasAtRight = isAtRight;
					elem.trigger('jsp-arrow-change', [wasAtTop, wasAtBottom, wasAtLeft, wasAtRight]);
				}

				updateHorizontalArrows(isAtLeft, isAtRight);
				pane.css('left', destLeft);
				elem.trigger('jsp-scroll-x', [-destLeft, isAtLeft, isAtRight]).trigger('scroll');
			}

			function updateVerticalArrows(isAtTop, isAtBottom) {
				if(settings.showArrows) {
					arrowUp[isAtTop ? 'addClass' : 'removeClass']('jspDisabled');
					arrowDown[isAtBottom ? 'addClass' : 'removeClass']('jspDisabled');
				}
			}

			function updateHorizontalArrows(isAtLeft, isAtRight) {
				if(settings.showArrows) {
					arrowLeft[isAtLeft ? 'addClass' : 'removeClass']('jspDisabled');
					arrowRight[isAtRight ? 'addClass' : 'removeClass']('jspDisabled');
				}
			}

			function scrollToY(destY, animate) {
				var percentScrolled = destY / (contentHeight - paneHeight);
				positionDragY(percentScrolled * dragMaxY, animate);
			}

			function scrollToX(destX, animate) {
				var percentScrolled = destX / (contentWidth - paneWidth);
				positionDragX(percentScrolled * dragMaxX, animate);
			}

			function scrollToElement(ele, stickToTop, animate) {
				var e, eleHeight, eleWidth, eleTop = 0, eleLeft = 0, viewportTop, viewportLeft, maxVisibleEleTop, maxVisibleEleLeft, destY, destX;

				// Legal hash values aren't necessarily legal jQuery selectors so we need to catch any
				// errors from the lookup...
				try {
					e = $(ele);
				} catch (err) {
					return;
				}
				eleHeight = e.outerHeight();
				eleWidth = e.outerWidth();

				container.scrollTop(0);
				container.scrollLeft(0);

				// loop through parents adding the offset top of any elements that are relatively positioned between
				// the focused element and the jspPane so we can get the true distance from the top
				// of the focused element to the top of the scrollpane...
				while(!e.is('.jspPane')) {
					eleTop += e.position().top;
					eleLeft += e.position().left;
					e = e.offsetParent();
					if(/^body|html$/i.test(e[0].nodeName)) {
						// we ended up too high in the document structure. Quit!
						return;
					}
				}
				viewportTop = contentPositionY();
				maxVisibleEleTop = viewportTop + paneHeight;
				if(eleTop < viewportTop || stickToTop) {// element is above viewport
					destY = eleTop - settings.verticalGutter;
				} else if(eleTop + eleHeight > maxVisibleEleTop) {// element is below viewport
					destY = eleTop - paneHeight + eleHeight + settings.verticalGutter;
				}
				if(destY) {
					scrollToY(destY, animate);
				}
				viewportLeft = contentPositionX();
				maxVisibleEleLeft = viewportLeft + paneWidth;
				if(eleLeft < viewportLeft || stickToTop) {// element is to the left of viewport
					destX = eleLeft - settings.horizontalGutter;
				} else if(eleLeft + eleWidth > maxVisibleEleLeft) {// element is to the right viewport
					destX = eleLeft - paneWidth + eleWidth + settings.horizontalGutter;
				}
				if(destX) {
					scrollToX(destX, animate);
				}

			}

			function contentPositionX() {
				return -pane.position().left;
			}

			function contentPositionY() {
				return -pane.position().top;
			}

			function isCloseToBottom() {
				var scrollableHeight = contentHeight - paneHeight;
				return (scrollableHeight > 20) && (scrollableHeight - contentPositionY() < 10);
			}

			function isCloseToRight() {
				var scrollableWidth = contentWidth - paneWidth;
				return (scrollableWidth > 20) && (scrollableWidth - contentPositionX() < 10);
			}

			function initMousewheel() {
				container.unbind(mwEvent).bind(mwEvent, function(event, delta, deltaX, deltaY) {
					var dX = horizontalDragPosition, dY = verticalDragPosition;
					jsp.scrollBy(deltaX * settings.mouseWheelSpeed, -deltaY * settings.mouseWheelSpeed, false);
					// return true if there was no movement so rest of screen can scroll
					return dX == horizontalDragPosition && dY == verticalDragPosition;
				});
			}

			function removeMousewheel() {
				container.unbind(mwEvent);
			}

			function nil() {
				return false;
			}

			function initFocusHandler() {
				pane.find(':input,a').unbind('focus.jsp').bind('focus.jsp', function(e) {
					scrollToElement(e.target, false);
				});
			}

			function removeFocusHandler() {
				pane.find(':input,a').unbind('focus.jsp');
			}

			function initKeyboardNav() {
				var keyDown, elementHasScrolled, validParents = [];
				isScrollableH && validParents.push(horizontalBar[0]);
				isScrollableV && validParents.push(verticalBar[0]);

				// IE also focuses elements that don't have tabindex set.
				pane.focus(function() {
					elem.focus();
				});

				elem.attr('tabindex', 0).unbind('keydown.jsp keypress.jsp').bind('keydown.jsp', function(e) {
					if(e.target !== this && !(validParents.length && $(e.target).closest(validParents).length)) {
						return;
					}
					var dX = horizontalDragPosition, dY = verticalDragPosition;
					switch(e.keyCode) {
						case 40:
						// down
						case 38:
						// up
						case 34:
						// page down
						case 32:
						// space
						case 33:
						// page up
						case 39:
						// right
						case 37:
							// left
							keyDown = e.keyCode;
							keyDownHandler();
							break;
						case 35:
							// end
							scrollToY(contentHeight - paneHeight);
							keyDown = null;
							break;
						case 36:
							// home
							scrollToY(0);
							keyDown = null;
							break;
					}
					elementHasScrolled = e.keyCode == keyDown && dX != horizontalDragPosition || dY != verticalDragPosition;
					return !elementHasScrolled;
				}).bind('keypress.jsp', // For FF/ OSX so that we can cancel the repeat key presses if the JSP scrolls...
				function(e) {
					if(e.keyCode == keyDown) {
						keyDownHandler();
					}
					return !elementHasScrolled;
				});
				if(settings.hideFocus) {
					elem.css('outline', 'none');
					if('hideFocus' in container[0]) {
						elem.attr('hideFocus', true);
					}
				} else {
					elem.css('outline', '');
					if('hideFocus' in container[0]) {
						elem.attr('hideFocus', false);
					}
				}

				function keyDownHandler() {
					var dX = horizontalDragPosition, dY = verticalDragPosition;
					switch(keyDown) {
						case 40:
							// down
							jsp.scrollByY(settings.keyboardSpeed, false);
							break;
						case 38:
							// up
							jsp.scrollByY(-settings.keyboardSpeed, false);
							break;
						case 34:
						// page down
						case 32:
							// space
							jsp.scrollByY(paneHeight * settings.scrollPagePercent, false);
							break;
						case 33:
							// page up
							jsp.scrollByY(-paneHeight * settings.scrollPagePercent, false);
							break;
						case 39:
							// right
							jsp.scrollByX(settings.keyboardSpeed, false);
							break;
						case 37:
							// left
							jsp.scrollByX(-settings.keyboardSpeed, false);
							break;
					}
					elementHasScrolled = dX != horizontalDragPosition || dY != verticalDragPosition;
					return elementHasScrolled;
				}

			}

			function removeKeyboardNav() {
				elem.attr('tabindex', '-1').removeAttr('tabindex').unbind('keydown.jsp keypress.jsp');
			}

			function observeHash() {
				if(location.hash && location.hash.length > 1) {
					var e, retryInt, hash = escape(location.hash)// hash must be escaped to prevent XSS
					;
					try {
						e = $(hash);
					} catch (err) {
						return;
					}

					if(e.length && pane.find(hash)) {
						// nasty workaround but it appears to take a little while before the hash has done its thing
						// to the rendered page so we just wait until the container's scrollTop has been messed up.
						if(container.scrollTop() === 0) {
							retryInt = setInterval(function() {
								if(container.scrollTop() > 0) {
									scrollToElement(hash, true);
									$(document).scrollTop(container.position().top);
									clearInterval(retryInt);
								}
							}, 50);
						} else {
							scrollToElement(hash, true);
							$(document).scrollTop(container.position().top);
						}
					}
				}
			}

			function unhijackInternalLinks() {
				$('a.jspHijack').unbind('click.jsp-hijack').removeClass('jspHijack');
			}

			function hijackInternalLinks() {
				unhijackInternalLinks();
				$('a[href^=#]').addClass('jspHijack').bind('click.jsp-hijack', function() {
					var uriParts = this.href.split('#'), hash;
					if(uriParts.length > 1) {
						hash = uriParts[1];
						if(hash.length > 0 && pane.find('#' + hash).length > 0) {
							scrollToElement('#' + hash, true);
							// Need to return false otherwise things mess up... Would be nice to maybe also scroll
							// the window to the top of the scrollpane?
							return false;
						}
					}
				});
			}

			// Init touch on iPad, iPhone, iPod, Android
			function initTouch() {
				var startX, startY, touchStartX, touchStartY, moved, moving = false;

				container.unbind('touchstart.jsp touchmove.jsp touchend.jsp click.jsp-touchclick').bind('touchstart.jsp', function(e) {
					var touch = e.originalEvent.touches[0];
					startX = contentPositionX();
					startY = contentPositionY();
					touchStartX = touch.pageX;
					touchStartY = touch.pageY;
					moved = false;
					moving = true;
				}).bind('touchmove.jsp', function(ev) {
					if(!moving) {
						return;
					}

					var touchPos = ev.originalEvent.touches[0], dX = horizontalDragPosition, dY = verticalDragPosition;

					jsp.scrollTo(startX + touchStartX - touchPos.pageX, startY + touchStartY - touchPos.pageY);
					moved = moved || Math.abs(touchStartX - touchPos.pageX) > 5 || Math.abs(touchStartY - touchPos.pageY) > 5;

					// return true if there was no movement so rest of screen can scroll
					return dX == horizontalDragPosition && dY == verticalDragPosition;
				}).bind('touchend.jsp', function(e) {
					moving = false;
					/*if(moved) {
					 return false;
					 }*/
				}).bind('click.jsp-touchclick', function(e) {
					if(moved) {
						moved = false;
						return false;
					}
				});
			}

			function destroy() {
				var currentY = contentPositionY(), currentX = contentPositionX();
				elem.removeClass('jspScrollable').unbind('.jsp');
				elem.replaceWith(originalElement.append(pane.children()));
				originalElement.scrollTop(currentY);
				originalElement.scrollLeft(currentX);
			}

			// Public API
			$.extend(jsp, {
				// Reinitialises the scroll pane (if it's internal dimensions have changed since the last time it
				// was initialised). The settings object which is passed in will override any settings from the
				// previous time it was initialised - if you don't pass any settings then the ones from the previous
				// initialisation will be used.
				reinitialise : function(s) {
					s = $.extend({}, settings, s);
					initialise(s);
				},
				// Scrolls the specified element (a jQuery object, DOM node or jQuery selector string) into view so
				// that it can be seen within the viewport. If stickToTop is true then the element will appear at
				// the top of the viewport, if it is false then the viewport will scroll as little as possible to
				// show the element. You can also specify if you want animation to occur. If you don't provide this
				// argument then the animateScroll value from the settings object is used instead.
				scrollToElement : function(ele, stickToTop, animate) {
					scrollToElement(ele, stickToTop, animate);
				},
				// Scrolls the pane so that the specified co-ordinates within the content are at the top left
				// of the viewport. animate is optional and if not passed then the value of animateScroll from
				// the settings object this jScrollPane was initialised with is used.
				scrollTo : function(destX, destY, animate) {
					scrollToX(destX, animate);
					scrollToY(destY, animate);
				},
				// Scrolls the pane so that the specified co-ordinate within the content is at the left of the
				// viewport. animate is optional and if not passed then the value of animateScroll from the settings
				// object this jScrollPane was initialised with is used.
				scrollToX : function(destX, animate) {
					scrollToX(destX, animate);
				},
				// Scrolls the pane so that the specified co-ordinate within the content is at the top of the
				// viewport. animate is optional and if not passed then the value of animateScroll from the settings
				// object this jScrollPane was initialised with is used.
				scrollToY : function(destY, animate) {
					scrollToY(destY, animate);
				},
				// Scrolls the pane to the specified percentage of its maximum horizontal scroll position. animate
				// is optional and if not passed then the value of animateScroll from the settings object this
				// jScrollPane was initialised with is used.
				scrollToPercentX : function(destPercentX, animate) {
					scrollToX(destPercentX * (contentWidth - paneWidth), animate);
				},
				// Scrolls the pane to the specified percentage of its maximum vertical scroll position. animate
				// is optional and if not passed then the value of animateScroll from the settings object this
				// jScrollPane was initialised with is used.
				scrollToPercentY : function(destPercentY, animate) {
					scrollToY(destPercentY * (contentHeight - paneHeight), animate);
				},
				// Scrolls the pane by the specified amount of pixels. animate is optional and if not passed then
				// the value of animateScroll from the settings object this jScrollPane was initialised with is used.
				scrollBy : function(deltaX, deltaY, animate) {
					jsp.scrollByX(deltaX, animate);
					jsp.scrollByY(deltaY, animate);
				},
				// Scrolls the pane by the specified amount of pixels. animate is optional and if not passed then
				// the value of animateScroll from the settings object this jScrollPane was initialised with is used.
				scrollByX : function(deltaX, animate) {
					var destX = contentPositionX() + Math[deltaX<0 ? 'floor' : 'ceil'](deltaX), percentScrolled = destX / (contentWidth - paneWidth);
					positionDragX(percentScrolled * dragMaxX, animate);
				},
				// Scrolls the pane by the specified amount of pixels. animate is optional and if not passed then
				// the value of animateScroll from the settings object this jScrollPane was initialised with is used.
				scrollByY : function(deltaY, animate) {
					var destY = contentPositionY() + Math[deltaY<0 ? 'floor' : 'ceil'](deltaY), percentScrolled = destY / (contentHeight - paneHeight);
					positionDragY(percentScrolled * dragMaxY, animate);
				},
				// Positions the horizontal drag at the specified x position (and updates the viewport to reflect
				// this). animate is optional and if not passed then the value of animateScroll from the settings
				// object this jScrollPane was initialised with is used.
				positionDragX : function(x, animate) {
					positionDragX(x, animate);
				},
				// Positions the vertical drag at the specified y position (and updates the viewport to reflect
				// this). animate is optional and if not passed then the value of animateScroll from the settings
				// object this jScrollPane was initialised with is used.
				positionDragY : function(y, animate) {
					positionDragY(y, animate);
				},
				// This method is called when jScrollPane is trying to animate to a new position. You can override
				// it if you want to provide advanced animation functionality. It is passed the following arguments:
				//  * ele          - the element whose position is being animated
				//  * prop         - the property that is being animated
				//  * value        - the value it's being animated to
				//  * stepCallback - a function that you must execute each time you update the value of the property
				// You can use the default implementation (below) as a starting point for your own implementation.
				animate : function(ele, prop, value, stepCallback) {
					var params = {};
					params[prop] = value;
					ele.animate(params, {
						'duration' : settings.animateDuration,
						'easing' : settings.animateEase,
						'queue' : false,
						'step' : stepCallback
					});
				},
				// Returns the current x position of the viewport with regards to the content pane.
				getContentPositionX : function() {
					return contentPositionX();
				},
				// Returns the current y position of the viewport with regards to the content pane.
				getContentPositionY : function() {
					return contentPositionY();
				},
				// Returns the width of the content within the scroll pane.
				getContentWidth : function() {
					return contentWidth;
				},
				// Returns the height of the content within the scroll pane.
				getContentHeight : function() {
					return contentHeight;
				},
				// Returns the horizontal position of the viewport within the pane content.
				getPercentScrolledX : function() {
					return contentPositionX() / (contentWidth - paneWidth);
				},
				// Returns the vertical position of the viewport within the pane content.
				getPercentScrolledY : function() {
					return contentPositionY() / (contentHeight - paneHeight);
				},
				// Returns whether or not this scrollpane has a horizontal scrollbar.
				getIsScrollableH : function() {
					return isScrollableH;
				},
				// Returns whether or not this scrollpane has a vertical scrollbar.
				getIsScrollableV : function() {
					return isScrollableV;
				},
				// Gets a reference to the content pane. It is important that you use this method if you want to
				// edit the content of your jScrollPane as if you access the element directly then you may have some
				// problems (as your original element has had additional elements for the scrollbars etc added into
				// it).
				getContentPane : function() {
					return pane;
				},
				// Scrolls this jScrollPane down as far as it can currently scroll. If animate isn't passed then the
				// animateScroll value from settings is used instead.
				scrollToBottom : function(animate) {
					positionDragY(dragMaxY, animate);
				},
				// Hijacks the links on the page which link to content inside the scrollpane. If you have changed
				// the content of your page (e.g. via AJAX) and want to make sure any new anchor links to the
				// contents of your scroll pane will work then call this function.
				hijackInternalLinks : function() {
					hijackInternalLinks();
				},
				// Removes the jScrollPane and returns the page to the state it was in before jScrollPane was
				// initialised.
				destroy : function() {
					destroy();
				}
			});

			initialise(s);
		}

		// Pluginifying code...
		settings = $.extend({}, $.fn.jScrollPane.defaults, settings);

		// Apply default speed
		$.each(['mouseWheelSpeed', 'arrowButtonSpeed', 'trackClickSpeed', 'keyboardSpeed'], function() {
			settings[this] = settings[this] || settings.speed;
		});
		return this.each(function() {
			var elem = $(this), jspApi = elem.data('jsp');
			if(jspApi) {
				jspApi.reinitialise(settings);
			} else {
				jspApi = new JScrollPane(elem, settings);
				elem.data('jsp', jspApi);
			}
		});
	};

	$.fn.jScrollPane.defaults = {
		showArrows : false,
		maintainPosition : true,
		stickToBottom : false,
		stickToRight : false,
		clickOnTrack : true,
		autoReinitialise : false,
		autoReinitialiseDelay : 500,
		verticalDragMinHeight : 0,
		verticalDragMaxHeight : 99999,
		horizontalDragMinWidth : 0,
		horizontalDragMaxWidth : 99999,
		contentWidth : undefined,
		animateScroll : false,
		animateDuration : 300,
		animateEase : 'linear',
		hijackInternalLinks : false,
		verticalGutter : 4,
		horizontalGutter : 4,
		mouseWheelSpeed : 0,
		arrowButtonSpeed : 0,
		arrowRepeatFreq : 50,
		arrowScrollOnHover : false,
		trackClickSpeed : 0,
		trackClickRepeatFreq : 70,
		verticalArrowPositions : 'split',
		horizontalArrowPositions : 'split',
		enableKeyboardNavigation : true,
		hideFocus : false,
		keyboardSpeed : 0,
		initialDelay : 300, // Delay before starting repeating
		speed : 30, // Default speed when others falsey
		scrollPagePercent : .8		// Percent of visible area scrolled when pageUp/Down or track area pressed
	};

})(jQuery, this);