jquery-ui-1.10.3/ui/jquery.ui.slider.js

/*!
 * 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();
                }

                this._trigger( "stop", event, uiHash );
        },

        _change: function( event, index ) {
                if ( !this._keySliding && !this._mouseSliding ) {
                        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();
                        }

                        //store the last changed value index for reference when handles overlap
                        this._lastChangedValue = index;

                        this._trigger( "change", event, uiHash );
                }
        },

        value: function( newValue ) {
                if ( arguments.length ) {
                        this.options.value = this._trimAlignValue( newValue );
                        this._refreshValue();
                        this._change( null, 0 );
                        return;
                }

                return this._value();
        },

        values: function( index, newValue ) {
                var vals,
                        newValues,
                        i;

                if ( arguments.length > 1 ) {
                        this.options.values[ index ] = this._trimAlignValue( newValue );
                        this._refreshValue();
                        this._change( null, index );
                        return;
                }

                if ( arguments.length ) {
                        if ( $.isArray( arguments[ 0 ] ) ) {
                                vals = this.options.values;
                                newValues = arguments[ 0 ];
                                for ( i = 0; i < vals.length; i += 1 ) {
                                        vals[ i ] = this._trimAlignValue( newValues[ i ] );
                                        this._change( null, i );
                                }
                                this._refreshValue();
                        } else {
                                if ( this.options.values && this.options.values.length ) {
                                        return this._values( index );
                                } else {
                                        return this.value();
                                }
                        }
                } else {
                        return this._values();
                }
        },

        _setOption: function( key, value ) {
                var i,
                        valsLength = 0;

                if ( key === "range" && this.options.range === true ) {
                        if ( value === "min" ) {
                                this.options.value = this._values( 0 );
                                this.options.values = null;
                        } else if ( value === "max" ) {
                                this.options.value = this._values( this.options.values.length-1 );
                                this.options.values = null;
                        }
                }

                if ( $.isArray( this.options.values ) ) {
                        valsLength = this.options.values.length;
                }

                $.Widget.prototype._setOption.apply( this, arguments );

                switch ( key ) {
                        case "orientation":
                                this._detectOrientation();
                                this.element
                                        .removeClass( "ui-slider-horizontal ui-slider-vertical" )
                                        .addClass( "ui-slider-" + this.orientation );
                                this._refreshValue();
                                break;
                        case "value":
                                this._animateOff = true;
                                this._refreshValue();
                                this._change( null, 0 );
                                this._animateOff = false;
                                break;
                        case "values":
                                this._animateOff = true;
                                this._refreshValue();
                                for ( i = 0; i < valsLength; i += 1 ) {
                                        this._change( null, i );
                                }
                                this._animateOff = false;
                                break;
                        case "min":
                        case "max":
                                this._animateOff = true;
                                this._refreshValue();
                                this._animateOff = false;
                                break;
                        case "range":
                                this._animateOff = true;
                                this._refresh();
                                this._animateOff = false;
                                break;
                }
        },

        //internal value getter
        // _value() returns value trimmed by min and max, aligned by step
        _value: function() {
                var val = this.options.value;
                val = this._trimAlignValue( val );

                return val;
        },

        //internal values getter
        // _values() returns array of values trimmed by min and max, aligned by step
        // _values( index ) returns single value trimmed by min and max, aligned by step
        _values: function( index ) {
                var val,
                        vals,
                        i;

                if ( arguments.length ) {
                        val = this.options.values[ index ];
                        val = this._trimAlignValue( val );

                        return val;
                } else if ( this.options.values && this.options.values.length ) {
                        // .slice() creates a copy of the array
                        // this copy gets trimmed by min and max and then returned
                        vals = this.options.values.slice();
                        for ( i = 0; i < vals.length; i+= 1) {
                                vals[ i ] = this._trimAlignValue( vals[ i ] );
                        }

                        return vals;
                } else {
                        return [];
                }
        },

        // returns the step-aligned value that val is closest to, between (inclusive) min and max
        _trimAlignValue: function( val ) {
                if ( val <= this._valueMin() ) {
                        return this._valueMin();
                }
                if ( val >= this._valueMax() ) {
                        return this._valueMax();
                }
                var step = ( this.options.step > 0 ) ? this.options.step : 1,
                        valModStep = (val - this._valueMin()) % step,
                        alignValue = val - valModStep;

                if ( Math.abs(valModStep) * 2 >= step ) {
                        alignValue += ( valModStep > 0 ) ? step : ( -step );
                }

                // Since JavaScript has problems with large floats, round
                // the final value to 5 digits after the decimal point (see #4124)
                return parseFloat( alignValue.toFixed(5) );
        },

        _valueMin: function() {
                return this.options.min;
        },

        _valueMax: function() {
                return this.options.max;
        },

        _refreshValue: function() {
                var lastValPercent, valPercent, value, valueMin, valueMax,
                        oRange = this.options.range,
                        o = this.options,
                        that = this,
                        animate = ( !this._animateOff ) ? o.animate : false,
                        _set = {};

                if ( this.options.values && this.options.values.length ) {
                        this.handles.each(function( i ) {
                                valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
                                _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
                                $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
                                if ( that.options.range === true ) {
                                        if ( that.orientation === "horizontal" ) {
                                                if ( i === 0 ) {
                                                        that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
                                                }
                                                if ( i === 1 ) {
                                                        that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
                                                }
                                        } else {
                                                if ( i === 0 ) {
                                                        that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
                                                }
                                                if ( i === 1 ) {
                                                        that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
                                                }
                                        }
                                }
                                lastValPercent = valPercent;
                        });
                } else {
                        value = this.value();
                        valueMin = this._valueMin();
                        valueMax = this._valueMax();
                        valPercent = ( valueMax !== valueMin ) ?
                                        ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
                                        0;
                        _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
                        this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );

                        if ( oRange === "min" && this.orientation === "horizontal" ) {
                                this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
                        }
                        if ( oRange === "max" && this.orientation === "horizontal" ) {
                                this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
                        }
                        if ( oRange === "min" && this.orientation === "vertical" ) {
                                this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
                        }
                        if ( oRange === "max" && this.orientation === "vertical" ) {
                                this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
                        }
                }
        },

        _handleEvents: {
                keydown: function( event ) {
                        /*jshint maxcomplexity:25*/
                        var allowed, curVal, newVal, step,
                                index = $( event.target ).data( "ui-slider-handle-index" );

                        switch ( event.keyCode ) {
                                case $.ui.keyCode.HOME:
                                case $.ui.keyCode.END:
                                case $.ui.keyCode.PAGE_UP:
                                case $.ui.keyCode.PAGE_DOWN:
                                case $.ui.keyCode.UP:
                                case $.ui.keyCode.RIGHT:
                                case $.ui.keyCode.DOWN:
                                case $.ui.keyCode.LEFT:
                                        event.preventDefault();
                                        if ( !this._keySliding ) {
                                                this._keySliding = true;
                                                $( event.target ).addClass( "ui-state-active" );
                                                allowed = this._start( event, index );
                                                if ( allowed === false ) {
                                                        return;
                                                }
                                        }
                                        break;
                        }

                        step = this.options.step;
                        if ( this.options.values && this.options.values.length ) {
                                curVal = newVal = this.values( index );
                        } else {
                                curVal = newVal = this.value();
                        }

                        switch ( event.keyCode ) {
                                case $.ui.keyCode.HOME:
                                        newVal = this._valueMin();
                                        break;
                                case $.ui.keyCode.END:
                                        newVal = this._valueMax();
                                        break;
                                case $.ui.keyCode.PAGE_UP:
                                        newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
                                        break;
                                case $.ui.keyCode.PAGE_DOWN:
                                        newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
                                        break;
                                case $.ui.keyCode.UP:
                                case $.ui.keyCode.RIGHT:
                                        if ( curVal === this._valueMax() ) {
                                                return;
                                        }
                                        newVal = this._trimAlignValue( curVal + step );
                                        break;
                                case $.ui.keyCode.DOWN:
                                case $.ui.keyCode.LEFT:
                                        if ( curVal === this._valueMin() ) {
                                                return;
                                        }
                                        newVal = this._trimAlignValue( curVal - step );
                                        break;
                        }

                        this._slide( event, index, newVal );
                },
                click: function( event ) {
                        event.preventDefault();
                },
                keyup: function( event ) {
                        var index = $( event.target ).data( "ui-slider-handle-index" );

                        if ( this._keySliding ) {
                                this._keySliding = false;
                                this._stop( event, index );
                                this._change( event, index );
                                $( event.target ).removeClass( "ui-state-active" );
                        }
                }
        }

});

}(jQuery));
1	/*!
2	* jQuery UI Slider 1.10.3
3	* http://jqueryui.com
4	*
5	* Copyright 2013 jQuery Foundation and other contributors
6	* Released under the MIT license.
7	* http://jquery.org/license
8	*
9	* http://api.jqueryui.com/slider/
10	*
11	* Depends:
12	* jquery.ui.core.js
13	* jquery.ui.mouse.js
14	* jquery.ui.widget.js
15	*/
16	(function( $, undefined ) {
17
18	// number of pages in a slider
19	// (how many times can you page up/down to go through the whole range)
20	var numPages = 5;
21
22	$.widget( "ui.slider", $.ui.mouse, {
23	version: "1.10.3",
24	widgetEventPrefix: "slide",
25
26	options: {
27	animate: false,
28	distance: 0,
29	max: 100,
30	min: 0,
31	orientation: "horizontal",
32	range: false,
33	step: 1,
34	value: 0,
35	values: null,
36
37	// callbacks
38	change: null,
39	slide: null,
40	start: null,
41	stop: null
42	},
43
44	_create: function() {
45	this._keySliding = false;
46	this._mouseSliding = false;
47	this._animateOff = true;
48	this._handleIndex = null;
49	this._detectOrientation();
50	this._mouseInit();
51
52	this.element
53	.addClass( "ui-slider" +
54	" ui-slider-" + this.orientation +
55	" ui-widget" +
56	" ui-widget-content" +
57	" ui-corner-all");
58
59	this._refresh();
60	this._setOption( "disabled", this.options.disabled );
61
62	this._animateOff = false;
63	},
64
65	_refresh: function() {
66	this._createRange();
67	this._createHandles();
68	this._setupEvents();
69	this._refreshValue();
70	},
71
72	_createHandles: function() {
73	var i, handleCount,
74	options = this.options,
75	existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
76	handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
77	handles = [];
78
79	handleCount = ( options.values && options.values.length ) \|\| 1;
80
81	if ( existingHandles.length > handleCount ) {
82	existingHandles.slice( handleCount ).remove();
83	existingHandles = existingHandles.slice( 0, handleCount );
84	}
85
86	for ( i = existingHandles.length; i < handleCount; i++ ) {
87	handles.push( handle );
88	}
89
90	this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
91
92	this.handle = this.handles.eq( 0 );
93
94	this.handles.each(function( i ) {
95	$( this ).data( "ui-slider-handle-index", i );
96	});
97	},
98
99	_createRange: function() {
100	var options = this.options,
101	classes = "";
102
103	if ( options.range ) {
104	if ( options.range === true ) {
105	if ( !options.values ) {
106	options.values = [ this._valueMin(), this._valueMin() ];
107	} else if ( options.values.length && options.values.length !== 2 ) {
108	options.values = [ options.values[0], options.values[0] ];
109	} else if ( $.isArray( options.values ) ) {
110	options.values = options.values.slice(0);
111	}
112	}
113
114	if ( !this.range \|\| !this.range.length ) {
115	this.range = $( "<div></div>" )
116	.appendTo( this.element );
117
118	classes = "ui-slider-range" +
119	// note: this isn't the most fittingly semantic framework class for this element,
120	// but worked best visually with a variety of themes
121	" ui-widget-header ui-corner-all";
122	} else {
123	this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
124	// Handle range switching from true to min/max
125	.css({
126	"left": "",
127	"bottom": ""
128	});
129	}
130
131	this.range.addClass( classes +
132	( ( options.range === "min" \|\| options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
133	} else {
134	this.range = $([]);
135	}
136	},
137
138	_setupEvents: function() {
139	var elements = this.handles.add( this.range ).filter( "a" );
140	this._off( elements );
141	this._on( elements, this._handleEvents );
142	this._hoverable( elements );
143	this._focusable( elements );
144	},
145
146	_destroy: function() {
147	this.handles.remove();
148	this.range.remove();
149
150	this.element
151	.removeClass( "ui-slider" +
152	" ui-slider-horizontal" +
153	" ui-slider-vertical" +
154	" ui-widget" +
155	" ui-widget-content" +
156	" ui-corner-all" );
157
158	this._mouseDestroy();
159	},
160
161	_mouseCapture: function( event ) {
162	var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
163	that = this,
164	o = this.options;
165
166	if ( o.disabled ) {
167	return false;
168	}
169
170	this.elementSize = {
171	width: this.element.outerWidth(),
172	height: this.element.outerHeight()
173	};
174	this.elementOffset = this.element.offset();
175
176	position = { x: event.pageX, y: event.pageY };
177	normValue = this._normValueFromMouse( position );
178	distance = this._valueMax() - this._valueMin() + 1;
179	this.handles.each(function( i ) {
180	var thisDistance = Math.abs( normValue - that.values(i) );
181	if (( distance > thisDistance ) \|\|
182	( distance === thisDistance &&
183	(i === that._lastChangedValue \|\| that.values(i) === o.min ))) {
184	distance = thisDistance;
185	closestHandle = $( this );
186	index = i;
187	}
188	});
189
190	allowed = this._start( event, index );
191	if ( allowed === false ) {
192	return false;
193	}
194	this._mouseSliding = true;
195
196	this._handleIndex = index;
197
198	closestHandle
199	.addClass( "ui-state-active" )
200	.focus();
201
202	offset = closestHandle.offset();
203	mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
204	this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
205	left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
206	top: event.pageY - offset.top -
207	( closestHandle.height() / 2 ) -
208	( parseInt( closestHandle.css("borderTopWidth"), 10 ) \|\| 0 ) -
209	( parseInt( closestHandle.css("borderBottomWidth"), 10 ) \|\| 0) +
210	( parseInt( closestHandle.css("marginTop"), 10 ) \|\| 0)
211	};
212
213	if ( !this.handles.hasClass( "ui-state-hover" ) ) {
214	this._slide( event, index, normValue );
215	}
216	this._animateOff = true;
217	return true;
218	},
219
220	_mouseStart: function() {
221	return true;
222	},
223
224	_mouseDrag: function( event ) {
225	var position = { x: event.pageX, y: event.pageY },
226	normValue = this._normValueFromMouse( position );
227
228	this._slide( event, this._handleIndex, normValue );
229
230	return false;
231	},
232
233	_mouseStop: function( event ) {
234	this.handles.removeClass( "ui-state-active" );
235	this._mouseSliding = false;
236
237	this._stop( event, this._handleIndex );
238	this._change( event, this._handleIndex );
239
240	this._handleIndex = null;
241	this._clickOffset = null;
242	this._animateOff = false;
243
244	return false;
245	},
246
247	_detectOrientation: function() {
248	this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
249	},
250
251	_normValueFromMouse: function( position ) {
252	var pixelTotal,
253	pixelMouse,
254	percentMouse,
255	valueTotal,
256	valueMouse;
257
258	if ( this.orientation === "horizontal" ) {
259	pixelTotal = this.elementSize.width;
260	pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
261	} else {
262	pixelTotal = this.elementSize.height;
263	pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
264	}
265
266	percentMouse = ( pixelMouse / pixelTotal );
267	if ( percentMouse > 1 ) {
268	percentMouse = 1;
269	}
270	if ( percentMouse < 0 ) {
271	percentMouse = 0;
272	}
273	if ( this.orientation === "vertical" ) {
274	percentMouse = 1 - percentMouse;
275	}
276
277	valueTotal = this._valueMax() - this._valueMin();
278	valueMouse = this._valueMin() + percentMouse * valueTotal;
279
280	return this._trimAlignValue( valueMouse );
281	},
282
283	_start: function( event, index ) {
284	var uiHash = {
285	handle: this.handles[ index ],
286	value: this.value()
287	};
288	if ( this.options.values && this.options.values.length ) {
289	uiHash.value = this.values( index );
290	uiHash.values = this.values();
291	}
292	return this._trigger( "start", event, uiHash );
293	},
294
295	_slide: function( event, index, newVal ) {
296	var otherVal,
297	newValues,
298	allowed;
299
300	if ( this.options.values && this.options.values.length ) {
301	otherVal = this.values( index ? 0 : 1 );
302
303	if ( ( this.options.values.length === 2 && this.options.range === true ) &&
304	( ( index === 0 && newVal > otherVal) \|\| ( index === 1 && newVal < otherVal ) )
305	) {
306	newVal = otherVal;
307	}
308
309	if ( newVal !== this.values( index ) ) {
310	newValues = this.values();
311	newValues[ index ] = newVal;
312	// A slide can be canceled by returning false from the slide callback
313	allowed = this._trigger( "slide", event, {
314	handle: this.handles[ index ],
315	value: newVal,
316	values: newValues
317	} );
318	otherVal = this.values( index ? 0 : 1 );
319	if ( allowed !== false ) {
320	this.values( index, newVal, true );
321	}
322	}
323	} else {
324	if ( newVal !== this.value() ) {
325	// A slide can be canceled by returning false from the slide callback
326	allowed = this._trigger( "slide", event, {
327	handle: this.handles[ index ],
328	value: newVal
329	} );
330	if ( allowed !== false ) {
331	this.value( newVal );
332	}
333	}
334	}
335	},
336
337	_stop: function( event, index ) {
338	var uiHash = {
339	handle: this.handles[ index ],
340	value: this.value()
341	};
342	if ( this.options.values && this.options.values.length ) {
343	uiHash.value = this.values( index );
344	uiHash.values = this.values();
345	}
346
347	this._trigger( "stop", event, uiHash );
348	},
349
350	_change: function( event, index ) {
351	if ( !this._keySliding && !this._mouseSliding ) {
352	var uiHash = {
353	handle: this.handles[ index ],
354	value: this.value()
355	};
356	if ( this.options.values && this.options.values.length ) {
357	uiHash.value = this.values( index );
358	uiHash.values = this.values();
359	}
360
361	//store the last changed value index for reference when handles overlap
362	this._lastChangedValue = index;
363
364	this._trigger( "change", event, uiHash );
365	}
366	},
367
368	value: function( newValue ) {
369	if ( arguments.length ) {
370	this.options.value = this._trimAlignValue( newValue );
371	this._refreshValue();
372	this._change( null, 0 );
373	return;
374	}
375
376	return this._value();
377	},
378
379	values: function( index, newValue ) {
380	var vals,
381	newValues,
382	i;
383
384	if ( arguments.length > 1 ) {
385	this.options.values[ index ] = this._trimAlignValue( newValue );
386	this._refreshValue();
387	this._change( null, index );
388	return;
389	}
390
391	if ( arguments.length ) {
392	if ( $.isArray( arguments[ 0 ] ) ) {
393	vals = this.options.values;
394	newValues = arguments[ 0 ];
395	for ( i = 0; i < vals.length; i += 1 ) {
396	vals[ i ] = this._trimAlignValue( newValues[ i ] );
397	this._change( null, i );
398	}
399	this._refreshValue();
400	} else {
401	if ( this.options.values && this.options.values.length ) {
402	return this._values( index );
403	} else {
404	return this.value();
405	}
406	}
407	} else {
408	return this._values();
409	}
410	},
411
412	_setOption: function( key, value ) {
413	var i,
414	valsLength = 0;
415
416	if ( key === "range" && this.options.range === true ) {
417	if ( value === "min" ) {
418	this.options.value = this._values( 0 );
419	this.options.values = null;
420	} else if ( value === "max" ) {
421	this.options.value = this._values( this.options.values.length-1 );
422	this.options.values = null;
423	}
424	}
425
426	if ( $.isArray( this.options.values ) ) {
427	valsLength = this.options.values.length;
428	}
429
430	$.Widget.prototype._setOption.apply( this, arguments );
431
432	switch ( key ) {
433	case "orientation":
434	this._detectOrientation();
435	this.element
436	.removeClass( "ui-slider-horizontal ui-slider-vertical" )
437	.addClass( "ui-slider-" + this.orientation );
438	this._refreshValue();
439	break;
440	case "value":
441	this._animateOff = true;
442	this._refreshValue();
443	this._change( null, 0 );
444	this._animateOff = false;
445	break;
446	case "values":
447	this._animateOff = true;
448	this._refreshValue();
449	for ( i = 0; i < valsLength; i += 1 ) {
450	this._change( null, i );
451	}
452	this._animateOff = false;
453	break;
454	case "min":
455	case "max":
456	this._animateOff = true;
457	this._refreshValue();
458	this._animateOff = false;
459	break;
460	case "range":
461	this._animateOff = true;
462	this._refresh();
463	this._animateOff = false;
464	break;
465	}
466	},
467
468	//internal value getter
469	// _value() returns value trimmed by min and max, aligned by step
470	_value: function() {
471	var val = this.options.value;
472	val = this._trimAlignValue( val );
473
474	return val;
475	},
476
477	//internal values getter
478	// _values() returns array of values trimmed by min and max, aligned by step
479	// _values( index ) returns single value trimmed by min and max, aligned by step
480	_values: function( index ) {
481	var val,
482	vals,
483	i;
484
485	if ( arguments.length ) {
486	val = this.options.values[ index ];
487	val = this._trimAlignValue( val );
488
489	return val;
490	} else if ( this.options.values && this.options.values.length ) {
491	// .slice() creates a copy of the array
492	// this copy gets trimmed by min and max and then returned
493	vals = this.options.values.slice();
494	for ( i = 0; i < vals.length; i+= 1) {
495	vals[ i ] = this._trimAlignValue( vals[ i ] );
496	}
497
498	return vals;
499	} else {
500	return [];
501	}
502	},
503
504	// returns the step-aligned value that val is closest to, between (inclusive) min and max
505	_trimAlignValue: function( val ) {
506	if ( val <= this._valueMin() ) {
507	return this._valueMin();
508	}
509	if ( val >= this._valueMax() ) {
510	return this._valueMax();
511	}
512	var step = ( this.options.step > 0 ) ? this.options.step : 1,
513	valModStep = (val - this._valueMin()) % step,
514	alignValue = val - valModStep;
515
516	if ( Math.abs(valModStep) * 2 >= step ) {
517	alignValue += ( valModStep > 0 ) ? step : ( -step );
518	}
519
520	// Since JavaScript has problems with large floats, round
521	// the final value to 5 digits after the decimal point (see #4124)
522	return parseFloat( alignValue.toFixed(5) );
523	},
524
525	_valueMin: function() {
526	return this.options.min;
527	},
528
529	_valueMax: function() {
530	return this.options.max;
531	},
532
533	_refreshValue: function() {
534	var lastValPercent, valPercent, value, valueMin, valueMax,
535	oRange = this.options.range,
536	o = this.options,
537	that = this,
538	animate = ( !this._animateOff ) ? o.animate : false,
539	_set = {};
540
541	if ( this.options.values && this.options.values.length ) {
542	this.handles.each(function( i ) {
543	valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
544	_set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
545	$( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
546	if ( that.options.range === true ) {
547	if ( that.orientation === "horizontal" ) {
548	if ( i === 0 ) {
549	that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
550	}
551	if ( i === 1 ) {
552	that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
553	}
554	} else {
555	if ( i === 0 ) {
556	that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
557	}
558	if ( i === 1 ) {
559	that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
560	}
561	}
562	}
563	lastValPercent = valPercent;
564	});
565	} else {
566	value = this.value();
567	valueMin = this._valueMin();
568	valueMax = this._valueMax();
569	valPercent = ( valueMax !== valueMin ) ?
570	( value - valueMin ) / ( valueMax - valueMin ) * 100 :
571	0;
572	_set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
573	this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
574
575	if ( oRange === "min" && this.orientation === "horizontal" ) {
576	this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
577	}
578	if ( oRange === "max" && this.orientation === "horizontal" ) {
579	this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
580	}
581	if ( oRange === "min" && this.orientation === "vertical" ) {
582	this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
583	}
584	if ( oRange === "max" && this.orientation === "vertical" ) {
585	this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
586	}
587	}
588	},
589
590	_handleEvents: {
591	keydown: function( event ) {
592	/jshint maxcomplexity:25/
593	var allowed, curVal, newVal, step,
594	index = $( event.target ).data( "ui-slider-handle-index" );
595
596	switch ( event.keyCode ) {
597	case $.ui.keyCode.HOME:
598	case $.ui.keyCode.END:
599	case $.ui.keyCode.PAGE_UP:
600	case $.ui.keyCode.PAGE_DOWN:
601	case $.ui.keyCode.UP:
602	case $.ui.keyCode.RIGHT:
603	case $.ui.keyCode.DOWN:
604	case $.ui.keyCode.LEFT:
605	event.preventDefault();
606	if ( !this._keySliding ) {
607	this._keySliding = true;
608	$( event.target ).addClass( "ui-state-active" );
609	allowed = this._start( event, index );
610	if ( allowed === false ) {
611	return;
612	}
613	}
614	break;
615	}
616
617	step = this.options.step;
618	if ( this.options.values && this.options.values.length ) {
619	curVal = newVal = this.values( index );
620	} else {
621	curVal = newVal = this.value();
622	}
623
624	switch ( event.keyCode ) {
625	case $.ui.keyCode.HOME:
626	newVal = this._valueMin();
627	break;
628	case $.ui.keyCode.END:
629	newVal = this._valueMax();
630	break;
631	case $.ui.keyCode.PAGE_UP:
632	newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
633	break;
634	case $.ui.keyCode.PAGE_DOWN:
635	newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
636	break;
637	case $.ui.keyCode.UP:
638	case $.ui.keyCode.RIGHT:
639	if ( curVal === this._valueMax() ) {
640	return;
641	}
642	newVal = this._trimAlignValue( curVal + step );
643	break;
644	case $.ui.keyCode.DOWN:
645	case $.ui.keyCode.LEFT:
646	if ( curVal === this._valueMin() ) {
647	return;
648	}
649	newVal = this._trimAlignValue( curVal - step );
650	break;
651	}
652
653	this._slide( event, index, newVal );
654	},
655	click: function( event ) {
656	event.preventDefault();
657	},
658	keyup: function( event ) {
659	var index = $( event.target ).data( "ui-slider-handle-index" );
660
661	if ( this._keySliding ) {
662	this._keySliding = false;
663	this._stop( event, index );
664	this._change( event, index );
665	$( event.target ).removeClass( "ui-state-active" );
666	}
667	}
668	}
669
670	});
671
672	}(jQuery));