/*

 * jQuery UI Slider 1.7.2

 *

 * Copyright (c) 2009 AUTHORS.txt (http://jqueryui.com/about)

 * Dual licensed under the MIT (MIT-LICENSE.txt)

 * and GPL (GPL-LICENSE.txt) licenses.

 *

 * http://docs.jquery.com/UI/Slider

 *

 * Depends:

 *	ui.core.js

 */

(function($) {

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

	_init: function() {

		var self = this, o = this.options;

		this._keySliding = false;

		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.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 != 2) {

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

				}

			} else {

				this.range = $('<div></div>');

			}

			this.range

				.appendTo(this.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 == 0)

			$('<a href="#"></a>')

				.appendTo(this.element)

				.addClass("ui-slider-handle");

		if (o.values && o.values.length) {

			while ($(".ui-slider-handle", this.element).length < o.values.length)

				$('<a href="#"></a>')

					.appendTo(this.element)

					.addClass("ui-slider-handle");

		}

		this.handles = $(".ui-slider-handle", this.element)

			.addClass("ui-state-default"

				+ " ui-corner-all");

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

		this.handles.add(this.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(i) {

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

		});

		this.handles.keydown(function(event) {

			var ret = true;

			var index = $(this).data("index.ui-slider-handle");

			if (self.options.disabled)

				return;

			switch (event.keyCode) {

				case $.ui.keyCode.HOME:

				case $.ui.keyCode.END:

				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");

						self._start(event, index);

					}

					break;

			}

			var curVal, newVal, step = self._step();

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

				curVal = newVal = self.values(index);

			} 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.UP:

				case $.ui.keyCode.RIGHT:

					if(curVal == self._valueMax()) return;

					newVal = curVal + step;

					break;

				case $.ui.keyCode.DOWN:

				case $.ui.keyCode.LEFT:

					if(curVal == self._valueMin()) return;

					newVal = curVal - step;

					break;

			}

			self._slide(event, index, newVal);

			return ret;

		}).keyup(function(event) {

			var index = $(this).data("index.ui-slider-handle");

			if (self._keySliding) {

				self._stop(event, index);

				self._change(event, index);

				self._keySliding = false;

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

			}

		});

		this._refreshValue();

	},

	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();

	},

	_mouseCapture: function(event) {

		var o = this.options;

		if (o.disabled)

			return false;

		this.elementSize = {

			width: this.element.outerWidth(),

			height: this.element.outerHeight()

		};

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

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

		var normValue = this._normValueFromMouse(position);

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

		var self = this, index;

		this.handles.each(function(i) {

			var thisDistance = Math.abs(normValue - 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) {

			closestHandle = $(this.handles[++index]);

		}

		this._start(event, index);

		self._handleIndex = index;

		closestHandle

			.addClass("ui-state-active")

			.focus();

		var offset = closestHandle.offset();

		var mouseOverHandle = !$(event.target).parents().andSelf().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)

		};

		normValue = this._normValueFromMouse(position);

		this._slide(event, index, normValue);

		return true;

	},

	_mouseStart: function(event) {

		return true;

	},

	_mouseDrag: function(event) {

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

		var normValue = this._normValueFromMouse(position);

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

		return false;

	},

	_mouseStop: function(event) {

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

		this._stop(event, this._handleIndex);

		this._change(event, this._handleIndex);

		this._handleIndex = null;

		this._clickOffset = null;

		return false;

	},

	_detectOrientation: function() {

		this.orientation = this.options.orientation == 'vertical' ? 'vertical' : 'horizontal';

	},

	_normValueFromMouse: function(position) {

		var pixelTotal, pixelMouse;

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

			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);

		}

		var percentMouse = (pixelMouse / pixelTotal);

		if (percentMouse > 1) percentMouse = 1;

		if (percentMouse < 0) percentMouse = 0;

		if ('vertical' == this.orientation)

			percentMouse = 1 - percentMouse;

		var valueTotal = this._valueMax() - this._valueMin(),

			valueMouse = percentMouse * valueTotal,

			valueMouseModStep = valueMouse % this.options.step,

			normValue = this._valueMin() + valueMouse - valueMouseModStep;

		if (valueMouseModStep > (this.options.step / 2))

			normValue += this.options.step;

		// Since JavaScript has problems with large floats, round

		// the final value to 5 digits after the decimal point (see #4124)

		return parseFloat(normValue.toFixed(5));

	},

	_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();

		}

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

	},

	_slide: function(event, index, newVal) {

		var handle = this.handles[index];

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

			var 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)) {

				var newValues = this.values();

				newValues[index] = newVal;

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

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

					handle: this.handles[index],

					value: newVal,

					values: newValues

				});

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

				if (allowed !== false) {

					this.values(index, newVal, ( event.type == 'mousedown' && this.options.animate ), true);