Subversion Repositories SmartDukaan

 * bootstrap-slider.js

 *

 * Maintainers:

 *		Kyle Kemp

 *			- Twitter: @seiyria

 *			- Github:  seiyria

 *		Rohit Kalkur

 *			- Twitter: @Rovolutionary

 *			- Github:  rovolution

 *

 * =========================================================

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * ========================================================= */

/**

 * Bridget makes jQuery widgets

 * v1.0.1

 * MIT license

 */

(function(root, factory) {

	if(typeof define === "function" && define.amd) {

		define(["jquery"], factory);

	} else if(typeof module === "object" && module.exports) {

		var jQuery;

		try {

			jQuery = require("jquery");

		} catch (err) {

			jQuery = null;

		}

		module.exports = factory(jQuery);

	} else {

		root.Slider = factory(root.jQuery);

	}

}(this, function($) {

	// Reference to Slider constructor

	var Slider;

	(function( $ ) {

		'use strict';

		// -------------------------- utils -------------------------- //

		var slice = Array.prototype.slice;

		function noop() {}

		// -------------------------- definition -------------------------- //

		function defineBridget( $ ) {

			// bail if no jQuery

			if ( !$ ) {

				return;

			}

			// -------------------------- addOptionMethod -------------------------- //

			/**

			 * adds option method -> $().plugin('option', {...})

			 * @param {Function} PluginClass - constructor class

			 */

			function addOptionMethod( PluginClass ) {

				// don't overwrite original option method

				if ( PluginClass.prototype.option ) {

					return;

				}

			  // option setter

			  PluginClass.prototype.option = function( opts ) {

			    // bail out if not an object

			    if ( !$.isPlainObject( opts ) ){

			      return;

			    }

			    this.options = $.extend( true, this.options, opts );

			  };

			}

			// -------------------------- plugin bridge -------------------------- //

			// helper function for logging errors

			// $.error breaks jQuery chaining

			var logError = typeof console === 'undefined' ? noop :

			  function( message ) {

			    console.error( message );

			  };

			/**

			 * jQuery plugin bridge, access methods like $elem.plugin('method')

			 * @param {String} namespace - plugin name

			 * @param {Function} PluginClass - constructor class

			 */

			function bridge( namespace, PluginClass ) {

			  // add to jQuery fn namespace

			  $.fn[ namespace ] = function( options ) {

			    if ( typeof options === 'string' ) {

			      // call plugin method when first argument is a string

			      // get arguments for method

			      var args = slice.call( arguments, 1 );

			      for ( var i=0, len = this.length; i < len; i++ ) {

			        var elem = this[i];

			        var instance = $.data( elem, namespace );

			        if ( !instance ) {

			          logError( "cannot call methods on " + namespace + " prior to initialization; " +

			            "attempted to call '" + options + "'" );

			          continue;

			        }

			        if ( !$.isFunction( instance[options] ) || options.charAt(0) === '_' ) {

			          logError( "no such method '" + options + "' for " + namespace + " instance" );

			          continue;

			        }

			        // trigger method with arguments

			        var returnValue = instance[ options ].apply( instance, args);

			        // break look and return first value if provided

			        if ( returnValue !== undefined && returnValue !== instance) {

			          return returnValue;

			        }

			      }

			      // return this if no return value

			      return this;

			    } else {

			      var objects = this.map( function() {

			        var instance = $.data( this, namespace );

			        if ( instance ) {

			          // apply options & init

			          instance.option( options );

			          instance._init();

			        } else {

			          // initialize new instance

			          instance = new PluginClass( this, options );

			          $.data( this, namespace, instance );

			        }

			        return $(this);

			      });

			      if(!objects || objects.length > 1) {

			      	return objects;

			      } else {

			      	return objects[0];

			      }

			    }

			  };

			}

			// -------------------------- bridget -------------------------- //

			/**

			 * converts a Prototypical class into a proper jQuery plugin

			 *   the class must have a ._init method

			 * @param {String} namespace - plugin name, used in $().pluginName

			 * @param {Function} PluginClass - constructor class

			 */

			$.bridget = function( namespace, PluginClass ) {

			  addOptionMethod( PluginClass );

			  bridge( namespace, PluginClass );

			};

			return $.bridget;

		}

	  	// get jquery from browser global

	  	defineBridget( $ );

	})( $ );

	/*************************************************

			BOOTSTRAP-SLIDER SOURCE CODE

	**************************************************/

	(function($) {

		var ErrorMsgs = {

			formatInvalidInputErrorMsg : function(input) {

				return "Invalid input value '" + input + "' passed in";

			},

			callingContextNotSliderInstance : "Calling context element does not have instance of Slider bound to it. Check your code to make sure the JQuery object returned from the call to the slider() initializer is calling the method"

		};

		/*************************************************

							CONSTRUCTOR

		**************************************************/

		Slider = function(element, options) {

			createNewSlider.call(this, element, options);

			return this;

		};

		function createNewSlider(element, options) {

			if(typeof element === "string") {

				this.element = document.querySelector(element);

			} else if(element instanceof HTMLElement) {

				this.element = element;

			}

			/*************************************************

							Process Options

			**************************************************/

			options = options ? options : {};

			var optionTypes = Object.keys(this.defaultOptions);

			for(var i = 0; i < optionTypes.length; i++) {

				var optName = optionTypes[i];

				// First check if an option was passed in via the constructor

				var val = options[optName];

				// If no data attrib, then check data atrributes

				val = (typeof val !== 'undefined') ? val : getDataAttrib(this.element, optName);

				// Finally, if nothing was specified, use the defaults

				val = (val !== null) ? val : this.defaultOptions[optName];

				// Set all options on the instance of the Slider

				if(!this.options) {

					this.options = {};

				}

				this.options[optName] = val;

			}

			function getDataAttrib(element, optName) {

				var dataName = "data-slider-" + optName;

				var dataValString = element.getAttribute(dataName);

				try {

					return JSON.parse(dataValString);

				}

				catch(err) {

					return dataValString;

				}

			}

			/*************************************************

							Create Markup

			**************************************************/

			var origWidth = this.element.style.width;

			var updateSlider = false;

			var parent = this.element.parentNode;

			var sliderTrackSelection;

			var sliderTrackLeft, sliderTrackRight;

			var sliderMinHandle;

			var sliderMaxHandle;

			if (this.sliderElem) {

				updateSlider = true;

			} else {

				/* Create elements needed for slider */

				this.sliderElem = document.createElement("div");

				this.sliderElem.className = "slider";

				/* Create slider track elements */

				var sliderTrack = document.createElement("div");

				sliderTrack.className = "slider-track";

				sliderTrackLeft = document.createElement("div");

				sliderTrackLeft.className = "slider-track-left";

				sliderTrackSelection = document.createElement("div");

				sliderTrackSelection.className = "slider-selection";

				sliderTrackRight = document.createElement("div");

				sliderTrackRight.className = "slider-track-right";

				sliderMinHandle = document.createElement("div");

				sliderMinHandle.className = "slider-handle min-slider-handle";

				sliderMaxHandle = document.createElement("div");

				sliderMaxHandle.className = "slider-handle max-slider-handle";

				sliderTrack.appendChild(sliderTrackLeft);

				sliderTrack.appendChild(sliderTrackSelection);

				sliderTrack.appendChild(sliderTrackRight);

				/* Create ticks */

				this.ticks = [];

				if (this.options.ticks instanceof Array && this.options.ticks.length > 0) {

					for (i = 0; i < this.options.ticks.length; i++) {

						var tick = document.createElement('div');

						tick.className = 'slider-tick';

						this.ticks.push(tick);

						sliderTrack.appendChild(tick);

					}

				}

				sliderTrack.appendChild(sliderMinHandle);

				sliderTrack.appendChild(sliderMaxHandle);

				this.tickLabels = [];

				if (this.options.ticks_labels instanceof Array && this.options.ticks_labels.length > 0) {

					this.tickLabelContainer = document.createElement('div');

					this.tickLabelContainer.className = 'slider-tick-label-container';

					for (i = 0; i < this.options.ticks_labels.length; i++) {

						var label = document.createElement('div');

						label.className = 'slider-tick-label';

						label.innerHTML = this.options.ticks_labels[i];

						this.tickLabels.push(label);

						this.tickLabelContainer.appendChild(label);

					}

				}

				var createAndAppendTooltipSubElements = function(tooltipElem) {

					var arrow = document.createElement("div");

					arrow.className = "tooltip-arrow";

					var inner = document.createElement("div");

					inner.className = "tooltip-inner";

					tooltipElem.appendChild(arrow);

					tooltipElem.appendChild(inner);

				};

				/* Create tooltip elements */

				var sliderTooltip = document.createElement("div");

				sliderTooltip.className = "tooltip tooltip-main";

				createAndAppendTooltipSubElements(sliderTooltip);

				var sliderTooltipMin = document.createElement("div");

				sliderTooltipMin.className = "tooltip tooltip-min";

				createAndAppendTooltipSubElements(sliderTooltipMin);

				var sliderTooltipMax = document.createElement("div");

				sliderTooltipMax.className = "tooltip tooltip-max";

				createAndAppendTooltipSubElements(sliderTooltipMax);

				/* Append components to sliderElem */

				this.sliderElem.appendChild(sliderTrack);

				this.sliderElem.appendChild(sliderTooltip);

				this.sliderElem.appendChild(sliderTooltipMin);

				this.sliderElem.appendChild(sliderTooltipMax);

				if (this.tickLabelContainer) {

					this.sliderElem.appendChild(this.tickLabelContainer);

				}

				/* Append slider element to parent container, right before the original <input> element */

				parent.insertBefore(this.sliderElem, this.element);

				/* Hide original <input> element */

				this.element.style.display = "none";

			}

			/* If JQuery exists, cache JQ references */

			if($) {

				this.$element = $(this.element);

				this.$sliderElem = $(this.sliderElem);

			}

			/*************************************************

								Setup

			**************************************************/

			this.eventToCallbackMap = {};

			this.sliderElem.id = this.options.id;

			this.touchCapable = 'ontouchstart' in window || (window.DocumentTouch && document instanceof window.DocumentTouch);

			this.tooltip = this.sliderElem.querySelector('.tooltip-main');

			this.tooltipInner = this.tooltip.querySelector('.tooltip-inner');

			this.tooltip_min = this.sliderElem.querySelector('.tooltip-min');

			this.tooltipInner_min = this.tooltip_min.querySelector('.tooltip-inner');

			this.tooltip_max = this.sliderElem.querySelector('.tooltip-max');

			this.tooltipInner_max= this.tooltip_max.querySelector('.tooltip-inner');

			if (updateSlider === true) {

				// Reset classes

				this._removeClass(this.sliderElem, 'slider-horizontal');

				this._removeClass(this.sliderElem, 'slider-vertical');

				this._removeClass(this.tooltip, 'hide');

				this._removeClass(this.tooltip_min, 'hide');

				this._removeClass(this.tooltip_max, 'hide');

				// Undo existing inline styles for track

				["left", "top", "width", "height"].forEach(function(prop) {

					this._removeProperty(this.trackLeft, prop);

					this._removeProperty(this.trackSelection, prop);

					this._removeProperty(this.trackRight, prop);

				}, this);

				// Undo inline styles on handles

				[this.handle1, this.handle2].forEach(function(handle) {

					this._removeProperty(handle, 'left');

					this._removeProperty(handle, 'top');

				}, this);

				// Undo inline styles and classes on tooltips

				[this.tooltip, this.tooltip_min, this.tooltip_max].forEach(function(tooltip) {

					this._removeProperty(tooltip, 'left');

					this._removeProperty(tooltip, 'top');

					this._removeProperty(tooltip, 'margin-left');

					this._removeProperty(tooltip, 'margin-top');

					this._removeClass(tooltip, 'right');

					this._removeClass(tooltip, 'top');

				}, this);

			}

			if(this.options.orientation === 'vertical') {

				this._addClass(this.sliderElem,'slider-vertical');

				this.stylePos = 'top';

				this.mousePos = 'pageY';

				this.sizePos = 'offsetHeight';

				this._addClass(this.tooltip, 'right');

				this.tooltip.style.left = '100%';

				this._addClass(this.tooltip_min, 'right');

				this.tooltip_min.style.left = '100%';

				this._addClass(this.tooltip_max, 'right');

				this.tooltip_max.style.left = '100%';

			} else {

				this._addClass(this.sliderElem, 'slider-horizontal');

				this.sliderElem.style.width = origWidth;

				this.options.orientation = 'horizontal';

				this.stylePos = 'left';

				this.mousePos = 'pageX';

				this.sizePos = 'offsetWidth';

				this._addClass(this.tooltip, 'top');

				this.tooltip.style.top = -this.tooltip.outerHeight - 14 + 'px';

				this._addClass(this.tooltip_min, 'top');

				this.tooltip_min.style.top = -this.tooltip_min.outerHeight - 14 + 'px';

				this._addClass(this.tooltip_max, 'top');

				this.tooltip_max.style.top = -this.tooltip_max.outerHeight - 14 + 'px';

			}

			/* In case ticks are specified, overwrite the min and max bounds */

			if (this.options.ticks instanceof Array && this.options.ticks.length > 0) {

					this.options.max = Math.max.apply(Math, this.options.ticks);

					this.options.min = Math.min.apply(Math, this.options.ticks);

			}

			if (this.options.value instanceof Array) {

				this.options.range = true;

			} else if (this.options.range) {

				// User wants a range, but value is not an array

				this.options.value = [this.options.value, this.options.max];

			}

			this.trackLeft = sliderTrackLeft || this.trackLeft;

			this.trackSelection = sliderTrackSelection || this.trackSelection;

			this.trackRight = sliderTrackRight || this.trackRight;

			if (this.options.selection === 'none') {

				this._addClass(this.trackLeft, 'hide');

				this._addClass(this.trackSelection, 'hide');

				this._addClass(this.trackRight, 'hide');

			}

			this.handle1 = sliderMinHandle || this.handle1;

			this.handle2 = sliderMaxHandle || this.handle2;

			if (updateSlider === true) {

				// Reset classes

				this._removeClass(this.handle1, 'round triangle');

				this._removeClass(this.handle2, 'round triangle hide');

				for (i = 0; i < this.ticks.length; i++) {

					this._removeClass(this.ticks[i], 'round triangle hide');

				}

			}

			var availableHandleModifiers = ['round', 'triangle', 'custom'];

			var isValidHandleType = availableHandleModifiers.indexOf(this.options.handle) !== -1;

			if (isValidHandleType) {

				this._addClass(this.handle1, this.options.handle);

				this._addClass(this.handle2, this.options.handle);

				for (i = 0; i < this.ticks.length; i++) {

					this._addClass(this.ticks[i], this.options.handle);

				}

			}

			this.offset = this._offset(this.sliderElem);

			this.size = this.sliderElem[this.sizePos];

			this.setValue(this.options.value);

			/******************************************

						Bind Event Listeners

			******************************************/

			// Bind keyboard handlers

			this.handle1Keydown = this._keydown.bind(this, 0);

			this.handle1.addEventListener("keydown", this.handle1Keydown, false);

			this.handle2Keydown = this._keydown.bind(this, 1);

			this.handle2.addEventListener("keydown", this.handle2Keydown, false);

			if (this.touchCapable) {

				// Bind touch handlers

				this.mousedown = this._mousedown.bind(this);

				this.sliderElem.addEventListener("touchstart", this.mousedown, false);

			} else {

				// Bind mouse handlers

				this.mousedown = this._mousedown.bind(this);

				this.sliderElem.addEventListener("mousedown", this.mousedown, false);

			}

			// Bind tooltip-related handlers

			if(this.options.tooltip === 'hide') {

				this._addClass(this.tooltip, 'hide');

				this._addClass(this.tooltip_min, 'hide');

				this._addClass(this.tooltip_max, 'hide');

			} else if(this.options.tooltip === 'always') {

				this._showTooltip();

				this._alwaysShowTooltip = true;

			} else {

				this.showTooltip = this._showTooltip.bind(this);

				this.hideTooltip = this._hideTooltip.bind(this);

				this.sliderElem.addEventListener("mouseenter", this.showTooltip, false);

				this.sliderElem.addEventListener("mouseleave", this.hideTooltip, false);

				this.handle1.addEventListener("focus", this.showTooltip, false);

				this.handle1.addEventListener("blur", this.hideTooltip, false);

				this.handle2.addEventListener("focus", this.showTooltip, false);

				this.handle2.addEventListener("blur", this.hideTooltip, false);

			}

			if(this.options.enabled) {

				this.enable();

			} else {

				this.disable();

			}

		}

		/*************************************************

					INSTANCE PROPERTIES/METHODS

		- Any methods bound to the prototype are considered

		part of the plugin's `public` interface

		**************************************************/

		Slider.prototype = {

			_init: function() {}, // NOTE: Must exist to support bridget

			constructor: Slider,

			defaultOptions: {

				id: "",

			  	min: 0,

				max: 10,

				step: 1,

				precision: 0,

				orientation: 'horizontal',

				value: 5,

				range: false,

				selection: 'before',

				tooltip: 'show',

				tooltip_split: false,

				handle: 'round',

				reversed: false,

				enabled: true,