Subversion Repositories Integrator Subversion

/**@preserve

$.fn.noUiSlider - WTFPL - refreshless.com/nouislider/ */

/*jslint browser: true */

/*jslint sub: true */

/*jslint white: true */

/*jslint continue: true */

/*jslint plusplus: true */

(function( $ ){

        'use strict';

        var

        // Cache the document selector;

        /** @const */

        doc = $(document),

        // Namespace for binding and unbinding slider events;

        /** @const */

        namespace = '.nui',

        // Determine the events to bind. IE11 implements pointerEvents without

        // a prefix, which breaks compatibility with the IE10 implementation.

        /** @const */

        actions = window.navigator['pointerEnabled'] ? {

                start: 'pointerdown',

                move: 'pointermove',

                end: 'pointerup'

        } : window.navigator['msPointerEnabled'] ? {

                start: 'MSPointerDown',

                move: 'MSPointerMove',

                end: 'MSPointerUp'

        } : {

                start: 'mousedown touchstart',

                move: 'mousemove touchmove',

                end: 'mouseup touchend'

        },

        // Re-usable list of classes;

        /** @const */

        Classes = [

/*  0 */  'noUi-target'

/*  1 */ ,'noUi-base'

/*  2 */ ,'noUi-origin'

/*  3 */ ,'noUi-handle'

/*  4 */ ,'noUi-horizontal'

/*  5 */ ,'noUi-vertical'

/*  6 */ ,'noUi-background'

/*  7 */ ,'noUi-connect'

/*  8 */ ,'noUi-ltr'

/*  9 */ ,'noUi-rtl'

/* 10 */ ,'noUi-dragable'

/* 11 */ ,''

/* 12 */ ,'noUi-state-drag'

/* 13 */ ,''

/* 14 */ ,'noUi-state-tap'

/* 15 */ ,'noUi-active'

/* 16 */ ,'noUi-extended'

/* 17 */ ,'noUi-stacking'

        ];

// General helpers

        // Limits a value to 0 - 100

        function limit ( a ) {

                return Math.max(Math.min(a, 100), 0);

        }

        // Round a value to the closest 'to'.

        function closest ( value, to ) {

                return Math.round(value / to) * to;

        }

        // Determine the size of a sub-range in relation to a full range.

        function subRangeRatio ( pa, pb ) {

                return (100 / (pb - pa));

        }

// Type validation

        // Checks whether a value is numerical.

        function isNumeric ( a ) {

                return typeof a === 'number' && !isNaN( a ) && isFinite( a );

        }

        // Wraps a variable as an array, if it isn't one yet.

        function asArray ( a ) {

                return $.isArray(a) ? a : [a];

        }

// Class handling

        // Sets a class and removes it after [duration] ms.

        function addClassFor ( element, className, duration ) {

                element.addClass(className);

                setTimeout(function(){

                        element.removeClass(className);

                }, duration);

        }

// Value calculation

        // (percentage) How many percent is this value of this range?

        function fromPercentage ( range, value ) {

                return (value * 100) / ( range[1] - range[0] );

        }

        // (percentage) Where is this value on this range?

        function toPercentage ( range, value ) {

                return fromPercentage( range, range[0] < 0 ?

                        value + Math.abs(range[0]) :

                                value - range[0] );

        }

        // (value) How much is this percentage on this range?

        function isPercentage ( range, value ) {

                return ((value * ( range[1] - range[0] )) / 100) + range[0];

        }

        // (percentage)

        function toStepping ( options, value ) {

                if ( value >= options.xVal.slice(-1)[0] ){

                        return 100;

                }

                var j = 1, va, vb, pa, pb;

                while ( value >= options.xVal[j] ){

                        j++;

                }

                va = options.xVal[j-1];

                vb = options.xVal[j];

                pa = options.xPct[j-1];

                pb = options.xPct[j];

                return pa + (toPercentage([va, vb], value) / subRangeRatio (pa, pb));

        }

        // (value)

        function fromStepping ( options, value ) {

                // There is no range group that fits 100

                if ( value >= 100 ){

                        return options.xVal.slice(-1)[0];

                }

                var j = 1, va, vb, pa, pb;

                while ( value >= options.xPct[j] ){

                        j++;

                }

                va = options.xVal[j-1];

                vb = options.xVal[j];

                pa = options.xPct[j-1];

                pb = options.xPct[j];

                return isPercentage([va, vb], (value - pa) * subRangeRatio (pa, pb));

        }

        // (percentage) Get the step that applies at a certain value.

        function getStep ( options, value ){

                var j = 1, a, b;

                while ( value >= options.xPct[j] ){

                        j++;

                }

                if ( options.snap ) {

                        a = options.xPct[j-1];

                        b = options.xPct[j];

                        if ((value - a) > ((b-a)/2)){

                                return b;

                        }

                        return a;

                }

                if ( !options.xSteps[j-1] ){

                        return value;

                }

                return options.xPct[j-1] + closest(

                        value - options.xPct[j-1],

                        options.xSteps[j-1]

                );

        }

// Event handling

        // Provide a clean event with standardized offset values.

        function fixEvent ( e ) {

                // Prevent scrolling and panning on touch events, while

                // attempting to slide. The tap event also depends on this.

                e.preventDefault();

                // Filter the event to register the type, which can be

                // touch, mouse or pointer. Offset changes need to be

                // made on an event specific basis.

                var  touch = e.type.indexOf('touch') === 0

                        ,mouse = e.type.indexOf('mouse') === 0

                        ,pointer = e.type.indexOf('pointer') === 0

                        ,x,y, event = e;

                // IE10 implemented pointer events with a prefix;

                if ( e.type.indexOf('MSPointer') === 0 ) {

                        pointer = true;

                }

                // Get the originalEvent, if the event has been wrapped

                // by jQuery. Zepto doesn't wrap the event.

                if ( e.originalEvent ) {

                        e = e.originalEvent;

                }

                if ( touch ) {

                        // noUiSlider supports one movement at a time,

                        // so we can select the first 'changedTouch'.

                        x = e.changedTouches[0].pageX;

                        y = e.changedTouches[0].pageY;

                }

                if ( mouse || pointer ) {

                        // Polyfill the pageXOffset and pageYOffset

                        // variables for IE7 and IE8;

                        if( !pointer && window.pageXOffset === undefined ){

                                window.pageXOffset = document.documentElement.scrollLeft;

                                window.pageYOffset = document.documentElement.scrollTop;

                        }

                        x = e.clientX + window.pageXOffset;

                        y = e.clientY + window.pageYOffset;

                }

                event.points = [x, y];

                event.cursor = mouse;

                return event;

        }

// Input validation

        function testStep ( parsed, entry ) {

                if ( !isNumeric( entry ) ) {

                        throw new Error("noUiSlider: 'step' is not numeric.");

                }

                // The step option can still be used to set stepping

                // for linear sliders. Overwritten if set in 'range'.

                parsed.xSteps[0] = entry;

        }

        function testRange ( parsed, entry ) {

                // Filter incorrect input.

                if ( typeof entry !== 'object' || $.isArray(entry) ) {

                        throw new Error("noUiSlider: 'range' is not an object.");

                }

                // Loop all entries.

                $.each( entry, function ( index, value ) {

                        var percentage;

                        // Wrap numerical input in an array.

                        if ( typeof value === "number" ) {

                                value = [value];

                        }

                        // Reject any invalid input.

                        if ( !$.isArray( value ) ){

                                throw new Error("noUiSlider: 'range' contains invalid value.");

                        }

                        // Covert min/max syntax to 0 and 100.

                        if ( index === 'min' ) {

                                percentage = 0;

                        } else if ( index === 'max' ) {

                                percentage = 100;

                        } else {

                                percentage = parseFloat( index );

                        }

                        // Check for correct input.

                        if ( !isNumeric( percentage ) || !isNumeric( value[0] ) ) {

                                throw new Error("noUiSlider: 'range' value isn't numeric.");

                        }

                        // Store values.

                        parsed.xPct.push( percentage );

                        parsed.xVal.push( value[0] );

                        // NaN will evaluate to false too, but to keep

                        // logging clear, set step explicitly. Make sure

                        // not to override the 'step' setting with false.

                        if ( !percentage ) {

                                if ( !isNaN( value[1] ) ) {

                                        parsed.xSteps[0] = value[1];

                                }

                        } else {

                                parsed.xSteps.push( isNaN(value[1]) ? false : value[1] );

                        }

                });

                $.each(parsed.xSteps, function(i,n){

                        // Ignore 'false' stepping.

                        if ( !n ) {

                                return true;

                        }

                        // Check if step fits. Not required, but this might serve some goal.

                        // !((parsed.xVal[i+1] - parsed.xVal[i]) % n);

                        // Factor to range ratio

                        parsed.xSteps[i] = fromPercentage([

                                 parsed.xVal[i]

                                ,parsed.xVal[i+1]

                        ], n) / subRangeRatio (

                                parsed.xPct[i],

                                parsed.xPct[i+1] );

                });

        }

        function testStart ( parsed, entry ) {

                if ( typeof entry === "number" ) {

                        entry = [entry];

                }

                // Validate input. Values aren't tested, the internal Link will do

                // that and provide a valid location.

                if ( !$.isArray( entry ) || !entry.length || entry.length > 2 ) {

                        throw new Error("noUiSlider: 'start' option is incorrect.");

                }

                // Store the number of handles.

                parsed.handles = entry.length;

                // When the slider is initialized, the .val method will

                // be called with the start options.

                parsed.start = entry;

        }

        function testSnap ( parsed, entry ) {

                // Enforce 100% stepping within subranges.

                parsed.snap = entry;

                if ( typeof entry !== 'boolean' ){

                        throw new Error("noUiSlider: 'snap' option must be a boolean.");

                }

        }

        function testConnect ( parsed, entry ) {

                if ( entry === 'lower' && parsed.handles === 1 ) {

                        parsed.connect = 1;

                } else if ( entry === 'upper' && parsed.handles === 1 ) {

                        parsed.connect = 2;

                } else if ( entry === true && parsed.handles === 2 ) {

                        parsed.connect = 3;

                } else if ( entry === false ) {

                        parsed.connect = 0;

                } else {

                        throw new Error("noUiSlider: 'connect' option doesn't match handle count.");

                }

        }

        function testOrientation ( parsed, entry ) {

                // Set orientation to an a numerical value for easy

                // array selection.

                switch ( entry ){

                  case 'horizontal':

                        parsed.ort = 0;

                        break;

                  case 'vertical':

                        parsed.ort = 1;

                        break;

                  default:

                        throw new Error("noUiSlider: 'orientation' option is invalid.");

                }

        }

        function testMargin ( parsed, entry ) {

                if ( parsed.xPct.length > 2 ) {

                        throw new Error("noUiSlider: 'margin' option is only supported on linear sliders.");

                }

                // Parse value to range and store. As xVal is checked

                // to be no bigger than 2, use it as range.

                parsed.margin = fromPercentage(parsed.xVal, entry);

                if ( !isNumeric(entry) ){

                        throw new Error("noUiSlider: 'margin' option must be numeric.");

                }

        }

        function testDirection ( parsed, entry ) {

                // Set direction as a numerical value for easy parsing.

                // Invert connection for RTL sliders, so that the proper

                // handles get the connect/background classes.

                switch ( entry ) {

                  case 'ltr':

                        parsed.dir = 0;

                        break;

                  case 'rtl':

                        parsed.dir = 1;

                        parsed.connect = [0,2,1,3][parsed.connect];

                        break;

                  default:

                        throw new Error("noUiSlider: 'direction' option was not recognized.");

                }

        }

        function testBehaviour ( parsed, entry ) {

                // Make sure the input is a string.

                if ( typeof entry !== 'string' ) {

                        throw new Error("noUiSlider: 'behaviour' must be a string containing options.");

                }

                // Check if the string contains any keywords.

                // None are required.

                var tap = entry.indexOf('tap') >= 0,

                        extend = entry.indexOf('extend') >= 0,

                        drag = entry.indexOf('drag') >= 0,

                        fixed = entry.indexOf('fixed') >= 0,

                        snap = entry.indexOf('snap') >= 0;

                parsed.events = {

                        tap: tap || snap,

                        extend: extend,

                        drag: drag,

                        fixed: fixed,

                        snap: snap

                };

        }

        function testSerialization ( parsed, entry, sliders ) {

                parsed.ser = [ entry['lower'], entry['upper'] ];

                parsed.formatting = entry['format'];

                $.each( parsed.ser, function( index, linkInstances ){

                        // Check if the provided option is an array.

                        if ( !$.isArray(linkInstances) ) {

                                throw new Error("noUiSlider: 'serialization."+(!index ? 'lower' : 'upper')+"' must be an array.");

                        }

                        $.each(linkInstances, function(){

                                // Check if entry is a Link.

                                if ( !(this instanceof $.Link) ) {

                                        throw new Error("noUiSlider: 'serialization."+(!index ? 'lower' : 'upper')+"' can only contain Link instances.");

                                }

                                // Assign properties.

                                this.setIndex ( index );

                                this.setObject( sliders );

                                this.setFormatting( entry['format'] );

                        });

                });

                // If the slider has two handles and is RTL,

                // reverse the serialization input. For one handle,

                // lower is still lower.

                if ( parsed.dir && parsed.handles > 1 ) {

                        parsed.ser.reverse();

                }

        }

        // Test all developer settings and parse to assumption-safe values.

        function test ( options, sliders ){

        /*      Every input option is tested and parsed. This'll prevent

                endless validation in internal methods. These tests are

                structured with an item for every option available. An

                option can be marked as required by setting the 'r' flag.

                The testing function is provided with three arguments:

                        - The provided value for the option;

                        - A reference to the options object;

                        - The name for the option;

                The testing function returns false when an error is detected,

                or true when everything is OK. It can also modify the option

                object, to make sure all values can be correctly looped elsewhere. */

                var parsed = {

                         xPct: []

                        ,xVal: []

                        ,xSteps: [ false ]

                        ,margin: 0

                }, tests;

                tests = {

                        'step': { r: false, t: testStep },

                        'range': { r: true, t: testRange },

                        'start': { r: true, t: testStart },

                        'snap': { r: false, t: testSnap },

                        'connect': { r: true, t: testConnect },

                        'orientation': { r: false, t: testOrientation },

                        'margin': { r: false, t: testMargin },

                        'direction': { r: true, t: testDirection },

                        'behaviour': { r: true, t: testBehaviour },

                        'serialization': { r: true, t: testSerialization }

                };

                // Set defaults where applicable.

                options = $.extend({

                        'connect': false,

                        'direction': 'ltr',

                        'behaviour': 'tap',

                        'orientation': 'horizontal'

                }, options);

                // Make sure the test for serialization runs.

                options['serialization'] = $.extend({

                         'lower': []

                        ,'upper': []

                        ,'format': {}

                }, options['serialization']);

                // Run all options through a testing mechanism to ensure correct

                // input. It should be noted that options might get modified to

                // be handled properly. E.g. wrapping integers in arrays.

                $.each( tests, function( name, test ){

                        if ( options[name] === undefined ) {

                                if ( test.r ) {

                                        throw new Error("noUiSlider: '" + name + "' is required.");

                                }

                                return true;

                        }

                        test.t( parsed, options[name], sliders );

                });

                // Pre-define the styles.

                parsed.style = parsed.ort ? 'top' : 'left';

                return parsed;

        }

// DOM additions

        // Append a handle to the base.

        function addHandle ( options, index ) {

                var handle = $('<div><div/></div>').addClass( Classes[2] ),

                        additions = [ '-lower', '-upper' ];

                if ( options.dir ) {

                        additions.reverse();

                }

                handle.children().addClass(

                        Classes[3] + " " + Classes[3]+additions[index]

                );

                return handle;

        }

        // Create a copy of an element-creating Link.

        function addElement ( handle, link ) {

                // If the Link requires creation of a new element,

                // create this element and return a new Link instance.

                if ( link.el ) {

                        link = new $.Link({

                                'target': $(link.el).clone().appendTo( handle ),

                                'method': link.method,

                                'format': link.formatting

                        }, true);

                }

                // Otherwise, return the reference.

                return link;

        }

        // Loop all links for a handle.

        function addElements ( elements, handle, formatting ) {

                var index, list = [], standard = new $.Link({}, true);

                // Use the Link interface to provide unified

                // formatting for the .val() method.

                standard.setFormatting(formatting);

                // The list now contains at least one element.

                list.push( standard );

                // Loop all links in either 'lower' or 'upper'.

                for ( index = 0; index < elements.length; index++ ) {

                        list.push(addElement(handle, elements[index]));

                }

                return list;

        }

        // Go over all Links and assign them to a handle.

        function addLinks ( options, handles ) {

                var index, links = [];

                // Copy the links into a new array, instead of modifying

                // the 'options.ser' list. This allows replacement of the invalid

                // '.el' Links, while the others are still passed by reference.

                for ( index = 0; index < options.handles; index++ ) {

                        // Append a new array.

                        links[index] = addElements(

                                options.ser[index],

                                handles[index].children(),

                                options.formatting

                        );

                }

                return links;

        }

        // Add the proper connection classes.

        function addConnection ( connect, target, handles ) {

                // Apply the required connection classes to the elements

                // that need them. Some classes are made up for several

                // segments listed in the class list, to allow easy

                // renaming and provide a minor compression benefit.

                switch ( connect ) {

                        case 1: target.addClass( Classes[7] );

                                        handles[0].addClass( Classes[6] );

                                        break;

                        case 3: handles[1].addClass( Classes[6] );

                                        /* falls through */

                        case 2: handles[0].addClass( Classes[7] );

                                        /* falls through */

                        case 0: target.addClass(Classes[6]);

                                        break;

                }

        }

        // Add handles and loop Link elements.

        function addHandles ( options, base ) {

                var index, handles = [];

                // Append handles.

                for ( index = 0; index < options.handles; index++ ) {

                        // Keep a list of all added handles.

                        handles.push( addHandle( options, index ).appendTo(base) );

                }

                return handles;

        }

        // Initialize a single slider.

        function addSlider ( options, target ) {

                // Apply classes and data to the target.

                target.addClass([

                        Classes[0],

                        Classes[8 + options.dir],

                        Classes[4 + options.ort]

                ].join(' '));

                return $('<div/>').appendTo(target).addClass( Classes[1] );

        }

// Slider scope

function closure ( target, options, originalOptions ){

// Internal variables

        // All variables local to 'closure' are marked $.

        var $Target = $(target),

                $Locations = [-1, -1],

                $Base,

                $Serialization,

                $Handles;

        // Shorthand for base dimensions.

        function baseSize ( ) {

                return $Base[['width', 'height'][options.ort]]();

        }

// External event handling

        function fireEvents ( events ) {

                // Use the external api to get the values.

                // Wrap the values in an array, as .trigger takes

                // only one additional argument.

                var index, values = [ $Target.val() ];

                for ( index = 0; index < events.length; index++ ){

                        $Target.trigger(events[index], values);

                }

        }

// Handle placement

        // Test suggested values and apply margin, step.

        function setHandle ( handle, to, delimit ) {

                var n = handle[0] !== $Handles[0][0] ? 1 : 0,

                        lower = $Locations[0] + options.margin,

                        upper = $Locations[1] - options.margin;

                // Don't delimit range dragging.

                if ( delimit && $Handles.length > 1 ) {

                        to = n ? Math.max( to, lower ) : Math.min( to, upper );

                }

                // Handle the step option.

                if ( to < 100 ){

                        to = getStep(options, to);

                }

                // Limit to 0/100 for .val input, trim anything beyond 7 digits, as

                // JavaScript has some issues in its floating point implementation.

                to = limit(parseFloat(to.toFixed(7)));

                // Return falsy if handle can't move. False for 0 or 100 limit,

                // '0' for limiting by another handle.

                if ( to === $Locations[n] ) {

                        if ( $Handles.length === 1 ) {

                                return false;

                        }

                        return ( to === lower || to === upper ) ? 0 : false;

                }

                // Set the handle to the new position.

                handle.css( options.style, to + '%' );

                // Force proper handle stacking

                if ( handle.is(':first-child') ) {

                        handle.toggleClass(Classes[17], to > 50 );

                }

                // Update locations.

                $Locations[n] = to;

                // Invert the value if this is a right-to-left slider.

                if ( options.dir ) {

                        to = 100 - to;

                }

                // Write values to serialization Links.

                // Convert the value to the correct relative representation.

                // Convert the value to the slider stepping/range.

                $($Serialization[n]).each(function(){

                        this.write( fromStepping( options, to ), handle.children(), $Target );

                });

                return true;

        }

        // Delimit proposed values for handle positions.

        function getPositions ( a, b, delimit ) {

                // Add movement to current position.

                var c = a + b[0], d = a + b[1];