CLICK HERE TO BUY IT TODAY! OR GET IT FREE VIA TRIALPAY  

PHP Demo Application - Source Code

/Framework/Model/Vendor/jquery-ui/development-bundle/ui/jquery.ui.slider.js



/*
 * jQuery UI Slider 1.8.4
 *
 * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/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, {
		    widgetEventPrefix"slide",
		    options: {
			        animatefalse,
			        distance0,
			        max100,
			        min0,
			        orientation"horizontal",
			        rangefalse,
			        step1,
			        value0,
			        valuesnull
			    },
		    _create: function() {
			        var self this,
			            this.options;
			        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" );
			        if ( o.disabled ) {
				            this.element.addClass"ui-slider-disabled ui-disabled" );
				        }
			        this.range = $([]);
			        if ( o.range ) {
				            if ( o.range === true ) {
					                this.range = $( "<div></div>" );
					                if ( !o.values ) {
						                    o.values = [ this._valueMin(), this._valueMin() ];
						                }
					                if ( o.values.length && o.values.length !== ) {
						                    o.values = [ o.values[0], o.values[0] ];
						                }
					            } else {
					                this.range = $( "<div></div>" );
					            }
				            this.range
				                .appendTothis.element )
				                .addClass"ui-slider-range" );
				            if ( o.range === "min" || o.range === "max" ) {
					                this.range.addClass"ui-slider-range-" o.range );
					            }
				            // note: this isn't the most fittingly semantic framework class for this element,
				            // but worked best visually with a variety of themes
				            this.range.addClass"ui-widget-header" );
				        }
			        if ( $( ".ui-slider-handle"this.element ).length === ) {
				            $( "<a href='#'></a>" )
				                .appendTothis.element )
				                .addClass"ui-slider-handle" );
				        }
			        if ( o.values && o.values.length ) {
				            while ( $(".ui-slider-handle"this.element).length o.values.length ) {
					                $( "<a href='#'></a>" )
					                    .appendTothis.element )
					                    .addClass"ui-slider-handle" );
					            }
				        }
			        this.handles = $( ".ui-slider-handle"this.element )
			            .addClass"ui-state-default" +
			                " ui-corner-all" );
			        this.handle this.handles.eq);
			        this.handles.addthis.range ).filter"a" )
			            .click(function( event ) {
				                event.preventDefault();
				            })
			            .hover(function() {
				                if ( !o.disabled ) {
					                    $( this ).addClass"ui-state-hover" );
					                }
				            }, function() {
				                $( this ).removeClass"ui-state-hover" );
				            })
			            .focus(function() {
				                if ( !o.disabled ) {
					                    $( ".ui-slider .ui-state-focus" ).removeClass"ui-state-focus" );
					                    $( this ).addClass"ui-state-focus" );
					                } else {
					                    $( this ).blur();
					                }
				            })
			            .blur(function() {
				                $( this ).removeClass"ui-state-focus" );
				            });
			        this.handles.each(function( ) {
				            $( this ).data"index.ui-slider-handle");
				        });
			        this.handles
			            .keydown(function( event ) {
				                var ret true,
				                    index = $( this ).data"index.ui-slider-handle" ),
				                    allowed,
				                    curVal,
				                    newVal,
				                    step;
				                if ( self.options.disabled ) {
					                    return;
					                }
				                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:
					                        ret false;
					                        if ( !self._keySliding ) {
						                            self._keySliding true;
						                            $( this ).addClass"ui-state-active" );
						                            allowed self._starteventindex );
						                            if ( allowed === false ) {
							                                return;
							                            }
						                        }
					                        break;
					                }
				                step self.options.step;
				                if ( self.options.values && self.options.values.length ) {
					                    curVal newVal self.valuesindex );
					                } else {
					                    curVal newVal self.value();
					                }
				                switch ( event.keyCode ) {
					                    case $.ui.keyCode.HOME:
					                        newVal self._valueMin();
					                        break;
					                    case $.ui.keyCode.END:
					                        newVal self._valueMax();
					                        break;
					                    case $.ui.keyCode.PAGE_UP:
					                        newVal self._trimAlignValuecurVal + ( (self._valueMax() - self._valueMin()) / numPages ) );
					                        break;
					                    case $.ui.keyCode.PAGE_DOWN:
					                        newVal self._trimAlignValuecurVal - ( (self._valueMax() - self._valueMin()) / numPages ) );
					                        break;
					                    case $.ui.keyCode.UP:
					                    case $.ui.keyCode.RIGHT:
					                        if ( curVal === self._valueMax() ) {
						                            return;
						                        }
					                        newVal self._trimAlignValuecurVal step );
					                        break;
					                    case $.ui.keyCode.DOWN:
					                    case $.ui.keyCode.LEFT:
					                        if ( curVal === self._valueMin() ) {
						                            return;
						                        }
					                        newVal self._trimAlignValuecurVal step );
					                        break;
					                }
				                self._slideeventindexnewVal );
				                return ret;
				            })
			            .keyup(function( event ) {
				                var index = $( this ).data"index.ui-slider-handle" );
				                if ( self._keySliding ) {
					                    self._keySliding false;
					                    self._stopeventindex );
					                    self._changeeventindex );
					                    $( this ).removeClass"ui-state-active" );
					                }
				            });
			        this._refreshValue();
			        this._animateOff false;
			    },
		    destroy: function() {
			        this.handles.remove();
			        this.range.remove();
			        this.element
			            .removeClass"ui-slider" +
			                " ui-slider-horizontal" +
			                " ui-slider-vertical" +
			                " ui-slider-disabled" +
			                " ui-widget" +
			                " ui-widget-content" +
			                " ui-corner-all" )
			            .removeData"slider" )
			            .unbind".slider" );
			        this._mouseDestroy();
			        return this;
			    },
		    _mouseCapture: function( event ) {
			        var this.options,
			            position,
			            normValue,
			            distance,
			            closestHandle,
			            self,
			            index,
			            allowed,
			            offset,
			            mouseOverHandle;
			        if ( o.disabled ) {
				            return false;
				        }
			        this.elementSize = {
				            widththis.element.outerWidth(),
				            heightthis.element.outerHeight()
				        };
			        this.elementOffset this.element.offset();
			        position = { xevent.pageXyevent.pageY
				};
			        normValue this._normValueFromMouseposition );
			        distance this._valueMax() - this._valueMin() + 1;
			        self this;
			        this.handles.each(function( ) {
				            var thisDistance Math.absnormValue self.values(i) );
				            if ( distance thisDistance ) {
					                distance thisDistance;
					                closestHandle = $( this );
					                index i;
					            }
				        });
			        // workaround for bug #3736 (if both handles of a range are at 0,
			        // the first is always used as the one with least distance,
			        // and moving it is obviously prevented by preventing negative ranges)
			        if( o.range === true && this.values(1) === o.min ) {
				            index += 1;
				            closestHandle = $( this.handles[index] );
				        }
			        allowed this._starteventindex );
			        if ( allowed === false ) {
				            return false;
				        }
			        this._mouseSliding true;
			        self._handleIndex index;
			        closestHandle
			            .addClass"ui-state-active" )
			            .focus();
			        offset closestHandle.offset();
			        mouseOverHandle = !$( event.target ).parents().andSelf().is".ui-slider-handle" );
			        this._clickOffset mouseOverHandle ? { left0top0
				} : {
				            leftevent.pageX offset.left - ( closestHandle.width() / ),
				            topevent.pageY offset.top -
				                ( closestHandle.height() / ) -
				                ( parseIntclosestHandle.css("borderTopWidth"), 10 ) || ) -
				                ( parseIntclosestHandle.css("borderBottomWidth"), 10 ) || 0) +
				                ( parseIntclosestHandle.css("marginTop"), 10 ) || 0)
				        };
			        this._slideeventindexnormValue );
			        this._animateOff true;
			        return true;
			    },
		    _mouseStart: function( event ) {
			        return true;
			    },
		    _mouseDrag: function( event ) {
			        var position = { xevent.pageXyevent.pageY
				},
			            normValue this._normValueFromMouseposition );
			        this._slideeventthis._handleIndexnormValue );
			        return false;
			    },
		    _mouseStop: function( event ) {
			        this.handles.removeClass"ui-state-active" );
			        this._mouseSliding false;
			        this._stopeventthis._handleIndex );
			        this._changeeventthis._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.this.elementOffset.left - ( this._clickOffset this._clickOffset.left );
				        } else {
				            pixelTotal this.elementSize.height;
				            pixelMouse position.this.elementOffset.top - ( this._clickOffset this._clickOffset.top );
				        }
			        percentMouse = ( pixelMouse pixelTotal );
			        if ( percentMouse ) {
				            percentMouse 1;
				        }
			        if ( percentMouse ) {
				            percentMouse 0;
				        }
			        if ( this.orientation === "vertical" ) {
				            percentMouse percentMouse;
				        }
			        valueTotal this._valueMax() - this._valueMin();
			        valueMouse this._valueMin() + percentMouse valueTotal;
			        return this._trimAlignValuevalueMouse );
			    },
		    _start: function( eventindex ) {
			        var uiHash = {
				            handlethis.handlesindex ],
				            valuethis.value()
				        };
			        if ( this.options.values && this.options.values.length ) {
				            uiHash.value this.valuesindex );
				            uiHash.values this.values();
				        }
			        return this._trigger"start"eventuiHash );
			    },
		    _slide: function( eventindexnewVal ) {
			        var otherVal,
			            newValues,
			            allowed;
			        if ( this.options.values && this.options.values.length ) {
				            otherVal this.valuesindex );
				            if ( ( this.options.values.length === && this.options.range === true ) && 
				                    ( ( index === && newVal otherVal) || ( index === && newVal otherVal ) )
				                ) {
					                newVal otherVal;
					            }
				            if ( newVal !== this.valuesindex ) ) {
					                newValues this.values();
					                newValuesindex ] = newVal;
					                // A slide can be canceled by returning false from the slide callback
					                allowed this._trigger"slide"event, {
						                    handlethis.handlesindex ],
						                    valuenewVal,
						                    valuesnewValues
						                } );
					                otherVal this.valuesindex );
					                if ( allowed !== false ) {
						                    this.valuesindexnewValtrue );
						                }
					            }
				        } else {
				            if ( newVal !== this.value() ) {
					                // A slide can be canceled by returning false from the slide callback
					                allowed this._trigger"slide"event, {
						                    handlethis.handlesindex ],
						                    valuenewVal
						                } );
					                if ( allowed !== false ) {
						                    this.valuenewVal );
						                }
					            }
				        }
			    },
		    _stop: function( eventindex ) {
			        var uiHash = {
				            handlethis.handlesindex ],
				            valuethis.value()
				        };
			        if ( this.options.values && this.options.values.length ) {
				            uiHash.value this.valuesindex );
				            uiHash.values this.values();
				        }
			        this._trigger"stop"eventuiHash );
			    },
		    _change: function( eventindex ) {
			        if ( !this._keySliding && !this._mouseSliding ) {
				            var uiHash = {
					                handlethis.handlesindex ],
					                valuethis.value()
					            };
				            if ( this.options.values && this.options.values.length ) {
					                uiHash.value this.valuesindex );
					                uiHash.values this.values();
					            }
				            this._trigger"change"eventuiHash );
				        }
			    },
		    value: function( newValue ) {
			        if ( arguments.length ) {
				            this.options.value this._trimAlignValuenewValue );
				            this._refreshValue();
				            this._changenull);
				        }
			        return this._value();
			    },
		    values: function( indexnewValue ) {
			        var vals,
			            newValues,
			            i;
			        if ( arguments.length ) {
				            this.options.valuesindex ] = this._trimAlignValuenewValue );
				            this._refreshValue();
				            this._changenullindex );
				        }
			        if ( arguments.length ) {
				            if ( $.isArrayarguments] ) ) {
					                vals this.options.values;
					                newValues arguments];
					                for ( 0;
					 vals.length;
					 += ) {
						                    vals] = this._trimAlignValuenewValues] );
						                    this._changenull);
						                }
					                this._refreshValue();
					            } else {
					                if ( this.options.values && this.options.values.length ) {
						                    return this._valuesindex );
						                } else {
						                    return this.value();
						                }
					            }
				        } else {
				            return this._values();
				        }
			    },
		    _setOption: function( keyvalue ) {
			        var i,
			            valsLength 0;
			        if ( $.isArraythis.options.values ) ) {
				            valsLength this.options.values.length;
				        }
			        $.Widget.prototype._setOption.applythisarguments );
			        switch ( key ) {
				            case "disabled":
				                if ( value ) {
					                    this.handles.filter".ui-state-focus" ).blur();
					                    this.handles.removeClass"ui-state-hover" );
					                    this.handles.attr"disabled""disabled" );
					                    this.element.addClass"ui-disabled" );
					                } else {
					                    this.handles.removeAttr"disabled" );
					                    this.element.removeClass"ui-disabled" );
					                }
				                break;
				            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._changenull);
				                this._animateOff false;
				                break;
				            case "values":
				                this._animateOff true;
				                this._refreshValue();
				                for ( 0;
				 valsLength;
				 += ) {
					                    this._changenull);
					                }
				                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._trimAlignValueval );
			        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.valuesindex ];
				            val this._trimAlignValueval );
				            return val;
				        } else {
				            // .slice() creates a copy of the array
				            // this copy gets trimmed by min and max and then returned
				            vals this.options.values.slice();
				            for ( 0;
				 vals.length;
				 i+= 1) {
					                vals] = this._trimAlignValuevals] );
					            }
				            return vals;
				        }
			    },
		    // 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 ) ? this.options.step 1,
			            valModStep val step,
			            alignValue val valModStep;
			        if ( Math.abs(valModStep) * >= step ) {
				            alignValue += ( valModStep ) ? step : ( -step );
				        }
			        // Since JavaScript has problems with large floats, round
			        // the final value to 5 digits after the decimal point (see #4124)
			        return parseFloatalignValue.toFixed(5) );
			    },
		    _valueMin: function() {
			        return this.options.min;
			    },
		    _valueMax: function() {
			        return this.options.max;
			    },
		    _refreshValue: function() {
			        var oRange this.options.range,
			            this.options,
			            self this,
			            animate = ( !this._animateOff ) ? o.animate false,
			            valPercent,
			            _set {},
			            lastValPercent,
			            value,
			            valueMin,
			            valueMax;
			        if ( this.options.values && this.options.values.length ) {
				            this.handles.each(function( i) {
					                valPercent = ( self.values(i) - self._valueMin() ) / ( self._valueMax() - self._valueMin() ) * 100;
					                _setself.orientation === "horizontal" "left" "bottom" ] = valPercent "%";
					                $( this ).stop1)[ animate "animate" "css" ]( _seto.animate );
					                if ( self.options.range === true ) {
						                    if ( self.orientation === "horizontal" ) {
							                        if ( === ) {
								                            self.range.stop1)[ animate "animate" "css" ]( { leftvalPercent "%"
									}, o.animate );
								                        }
							                        if ( === ) {
								                            self.rangeanimate "animate" "css" ]( { width: ( valPercent lastValPercent ) + "%"
									}, { queuefalsedurationo.animate
									} );
								                        }
							                    } else {
							                        if ( === ) {
								                            self.range.stop1)[ animate "animate" "css" ]( { bottom: ( valPercent ) + "%"
									}, o.animate );
								                        }
							                        if ( === ) {
								                            self.rangeanimate "animate" "css" ]( { height: ( valPercent lastValPercent ) + "%"
									}, { queuefalsedurationo.animate
									} );
								                        }
							                    }
						                }
					                lastValPercent valPercent;
					            });
				        } else {
				            value this.value();
				            valueMin this._valueMin();
				            valueMax this._valueMax();
				            valPercent = ( valueMax !== valueMin ) ?
				                    ( value valueMin ) / ( valueMax valueMin ) * 100 :
				                    0;
				            _setself.orientation === "horizontal" "left" "bottom" ] = valPercent "%";
				            this.handle.stop1)[ animate "animate" "css" ]( _seto.animate );
				            if ( oRange === "min" && this.orientation === "horizontal" ) {
					                this.range.stop1)[ animate "animate" "css" ]( { widthvalPercent "%"
						}, o.animate );
					            }
				            if ( oRange === "max" && this.orientation === "horizontal" ) {
					                this.rangeanimate "animate" "css" ]( { width: ( 100 valPercent ) + "%"
						}, { queuefalsedurationo.animate
						} );
					            }
				            if ( oRange === "min" && this.orientation === "vertical" ) {
					                this.range.stop1)[ animate "animate" "css" ]( { heightvalPercent "%"
						}, o.animate );
					            }
				            if ( oRange === "max" && this.orientation === "vertical" ) {
					                this.rangeanimate "animate" "css" ]( { height: ( 100 valPercent ) + "%"
						}, { queuefalsedurationo.animate
						} );
					            }
				        }
			    }
		});
	$.extend( $.ui.slider, {
		    version"1.8.4"
		});
	}(jQuery));





PHP Demo Source Code Index