/*!

 * jQuery UI Slider 1.10.3

 * http://jqueryui.com

 *

 * Copyright 2013 jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 *

 * http://api.jqueryui.com/slider/

 *

 * Depends:

 *	jquery.ui.core.js

 *	jquery.ui.mouse.js

 *	jquery.ui.widget.js

 */

(function( $, undefined ) {

// number of pages in a slider

// (how many times can you page up/down to go through the whole range)

var numPages = 5;

$.widget( "ui.slider", $.ui.mouse, {

	version: "1.10.3",

	widgetEventPrefix: "slide",

	options: {

		animate: false,

		distance: 0,

		max: 100,

		min: 0,

		orientation: "horizontal",

		range: false,

		step: 1,

		value: 0,

		values: null,

		// callbacks

		change: null,

		slide: null,

		start: null,

		stop: null

	},

	_create: function() {

		this._keySliding = false;

		this._mouseSliding = false;

		this._animateOff = true;

		this._handleIndex = null;

		this._detectOrientation();

		this._mouseInit();

		this.element

			.addClass( "ui-slider" +

				" ui-slider-" + this.orientation +

				" ui-widget" +

				" ui-widget-content" +

				" ui-corner-all");

		this._refresh();

		this._setOption( "disabled", this.options.disabled );

		this._animateOff = false;

	},

	_refresh: function() {

		this._createRange();

		this._createHandles();

		this._setupEvents();

		this._refreshValue();

	},

	_createHandles: function() {

		var i, handleCount,

			options = this.options,

			existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),

			handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",

			handles = [];

		handleCount = ( options.values && options.values.length ) || 1;

		if ( existingHandles.length > handleCount ) {

			existingHandles.slice( handleCount ).remove();

			existingHandles = existingHandles.slice( 0, handleCount );

		}

		for ( i = existingHandles.length; i < handleCount; i++ ) {

			handles.push( handle );

		}

		this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );

		this.handle = this.handles.eq( 0 );

		this.handles.each(function( i ) {

			$( this ).data( "ui-slider-handle-index", i );

		});

	},

	_createRange: function() {

		var options = this.options,

			classes = "";

		if ( options.range ) {

			if ( options.range === true ) {

				if ( !options.values ) {

					options.values = [ this._valueMin(), this._valueMin() ];

				} else if ( options.values.length && options.values.length !== 2 ) {

					options.values = [ options.values[0], options.values[0] ];

				} else if ( $.isArray( options.values ) ) {

					options.values = options.values.slice(0);

				}

			}

			if ( !this.range || !this.range.length ) {

				this.range = $( "<div></div>" )

					.appendTo( this.element );

				classes = "ui-slider-range" +

				// note: this isn't the most fittingly semantic framework class for this element,

				// but worked best visually with a variety of themes

				" ui-widget-header ui-corner-all";

			} else {

				this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )

					// Handle range switching from true to min/max

					.css({

						"left": "",

						"bottom": ""

					});

			}

			this.range.addClass( classes +

				( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );

		} else {

			this.range = $([]);

		}

	},

	_setupEvents: function() {

		var elements = this.handles.add( this.range ).filter( "a" );

		this._off( elements );

		this._on( elements, this._handleEvents );

		this._hoverable( elements );

		this._focusable( elements );

	},

	_destroy: function() {

		this.handles.remove();

		this.range.remove();

		this.element

			.removeClass( "ui-slider" +

				" ui-slider-horizontal" +

				" ui-slider-vertical" +

				" ui-widget" +

				" ui-widget-content" +

				" ui-corner-all" );

		this._mouseDestroy();

	},

	_mouseCapture: function( event ) {

		var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,

			that = this,

			o = this.options;

		if ( o.disabled ) {

			return false;

		}

		this.elementSize = {

			width: this.element.outerWidth(),

			height: this.element.outerHeight()

		};

		this.elementOffset = this.element.offset();

		position = { x: event.pageX, y: event.pageY };

		normValue = this._normValueFromMouse( position );

		distance = this._valueMax() - this._valueMin() + 1;

		this.handles.each(function( i ) {

			var thisDistance = Math.abs( normValue - that.values(i) );

			if (( distance > thisDistance ) ||

				( distance === thisDistance &&

					(i === that._lastChangedValue || that.values(i) === o.min ))) {

				distance = thisDistance;

				closestHandle = $( this );

				index = i;

			}

		});

		allowed = this._start( event, index );

		if ( allowed === false ) {

			return false;

		}

		this._mouseSliding = true;

		this._handleIndex = index;

		closestHandle

			.addClass( "ui-state-active" )

			.focus();

		offset = closestHandle.offset();

		mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );

		this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {

			left: event.pageX - offset.left - ( closestHandle.width() / 2 ),

			top: event.pageY - offset.top -

				( closestHandle.height() / 2 ) -

				( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -

				( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +

				( parseInt( closestHandle.css("marginTop"), 10 ) || 0)

		};

		if ( !this.handles.hasClass( "ui-state-hover" ) ) {

			this._slide( event, index, normValue );

		}

		this._animateOff = true;

		return true;

	},

	_mouseStart: function() {

		return true;

	},

	_mouseDrag: function( event ) {

		var position = { x: event.pageX, y: event.pageY },

			normValue = this._normValueFromMouse( position );

		this._slide( event, this._handleIndex, normValue );

		return false;

	},

	_mouseStop: function( event ) {

		this.handles.removeClass( "ui-state-active" );

		this._mouseSliding = false;

		this._stop( event, this._handleIndex );

		this._change( event, this._handleIndex );

		this._handleIndex = null;

		this._clickOffset = null;

		this._animateOff = false;

		return false;

	},

	_detectOrientation: function() {

		this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";

	},

	_normValueFromMouse: function( position ) {

		var pixelTotal,

			pixelMouse,

			percentMouse,

			valueTotal,

			valueMouse;

		if ( this.orientation === "horizontal" ) {

			pixelTotal = this.elementSize.width;

			pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );

		} else {

			pixelTotal = this.elementSize.height;

			pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );

		}

		percentMouse = ( pixelMouse / pixelTotal );

		if ( percentMouse > 1 ) {

			percentMouse = 1;

		}

		if ( percentMouse < 0 ) {

			percentMouse = 0;

		}

		if ( this.orientation === "vertical" ) {

			percentMouse = 1 - percentMouse;

		}

		valueTotal = this._valueMax() - this._valueMin();

		valueMouse = this._valueMin() + percentMouse * valueTotal;

		return this._trimAlignValue( valueMouse );

	},

	_start: function( event, index ) {

		var uiHash = {

			handle: this.handles[ index ],

			value: this.value()

		};

		if ( this.options.values && this.options.values.length ) {

			uiHash.value = this.values( index );

			uiHash.values = this.values();

		}

		return this._trigger( "start", event, uiHash );

	},

	_slide: function( event, index, newVal ) {

		var otherVal,

			newValues,

			allowed;

		if ( this.options.values && this.options.values.length ) {

			otherVal = this.values( index ? 0 : 1 );

			if ( ( this.options.values.length === 2 && this.options.range === true ) &&

					( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )

				) {

				newVal = otherVal;

			}

			if ( newVal !== this.values( index ) ) {

				newValues = this.values();

				newValues[ index ] = newVal;

				// A slide can be canceled by returning false from the slide callback

				allowed = this._trigger( "slide", event, {

					handle: this.handles[ index ],

					value: newVal,

					values: newValues

				} );

				otherVal = this.values( index ? 0 : 1 );

				if ( allowed !== false ) {

					this.values( index, newVal, true );

				}

			}

		} else {

			if ( newVal !== this.value() ) {

				// A slide can be canceled by returning false from the slide callback

				allowed = this._trigger( "slide", event, {

					handle: this.handles[ index ],

					value: newVal

				} );

				if ( allowed !== false ) {

					this.value( newVal );

				}

			}

		}

	},

	_stop: function( event, index ) {

		var uiHash = {

			handle: this.handles[ index ],

			value: this.value()

		};

		if ( this.options.values && this.options.values.length ) {

			uiHash.value = this.values( index );

			uiHash.values = this.values();