/*!
* jQuery UI 1.8.1
*
* Copyright (c) 2010 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
*/
jQuery.ui || function(c) {
    c.ui = { version: "1.8.1", plugin: { add: function(a, b, d) { a = c.ui[a].prototype; for (var e in d) { a.plugins[e] = a.plugins[e] || []; a.plugins[e].push([b, d[e]]) } }, call: function(a, b, d) { if ((b = a.plugins[b]) && a.element[0].parentNode) for (var e = 0; e < b.length; e++) a.options[b[e][0]] && b[e][1].apply(a.element, d) } }, contains: function(a, b) { return document.compareDocumentPosition ? a.compareDocumentPosition(b) & 16 : a !== b && a.contains(b) }, hasScroll: function(a, b) {
        if (c(a).css("overflow") == "hidden") return false;
        b = b && b == "left" ? "scrollLeft" : "scrollTop"; var d = false; if (a[b] > 0) return true; a[b] = 1; d = a[b] > 0; a[b] = 0; return d
    }, isOverAxis: function(a, b, d) { return a > b && a < b + d }, isOver: function(a, b, d, e, f, g) { return c.ui.isOverAxis(a, d, f) && c.ui.isOverAxis(b, e, g) }, keyCode: { ALT: 18, BACKSPACE: 8, CAPS_LOCK: 20, COMMA: 188, CONTROL: 17, DELETE: 46, DOWN: 40, END: 35, ENTER: 13, ESCAPE: 27, HOME: 36, INSERT: 45, LEFT: 37, NUMPAD_ADD: 107, NUMPAD_DECIMAL: 110, NUMPAD_DIVIDE: 111, NUMPAD_ENTER: 108, NUMPAD_MULTIPLY: 106, NUMPAD_SUBTRACT: 109, PAGE_DOWN: 34, PAGE_UP: 33,
        PERIOD: 190, RIGHT: 39, SHIFT: 16, SPACE: 32, TAB: 9, UP: 38
    }
    }; c.fn.extend({ _focus: c.fn.focus, focus: function(a, b) { return typeof a === "number" ? this.each(function() { var d = this; setTimeout(function() { c(d).focus(); b && b.call(d) }, a) }) : this._focus.apply(this, arguments) }, enableSelection: function() { return this.attr("unselectable", "off").css("MozUserSelect", "") }, disableSelection: function() { return this.attr("unselectable", "on").css("MozUserSelect", "none") }, scrollParent: function() {
        var a; a = c.browser.msie && /(static|relative)/.test(this.css("position")) ||
/absolute/.test(this.css("position")) ? this.parents().filter(function() { return /(relative|absolute|fixed)/.test(c.curCSS(this, "position", 1)) && /(auto|scroll)/.test(c.curCSS(this, "overflow", 1) + c.curCSS(this, "overflow-y", 1) + c.curCSS(this, "overflow-x", 1)) }).eq(0) : this.parents().filter(function() { return /(auto|scroll)/.test(c.curCSS(this, "overflow", 1) + c.curCSS(this, "overflow-y", 1) + c.curCSS(this, "overflow-x", 1)) }).eq(0); return /fixed/.test(this.css("position")) || !a.length ? c(document) : a
    }, zIndex: function(a) {
        if (a !==
undefined) return this.css("zIndex", a); if (this.length) { a = c(this[0]); for (var b; a.length && a[0] !== document; ) { b = a.css("position"); if (b == "absolute" || b == "relative" || b == "fixed") { b = parseInt(a.css("zIndex")); if (!isNaN(b) && b != 0) return b } a = a.parent() } } return 0
    }
    }); c.extend(c.expr[":"], { data: function(a, b, d) { return !!c.data(a, d[3]) }, focusable: function(a) {
        var b = a.nodeName.toLowerCase(), d = c.attr(a, "tabindex"); return (/input|select|textarea|button|object/.test(b) ? !a.disabled : "a" == b || "area" == b ? a.href || !isNaN(d) : !isNaN(d)) &&
!c(a)["area" == b ? "parents" : "closest"](":hidden").length
    }, tabbable: function(a) { var b = c.attr(a, "tabindex"); return (isNaN(b) || b >= 0) && c(a).is(":focusable") }
    })
} (jQuery);
; /*!
 * jQuery UI Widget 1.8.1
 *
 * Copyright (c) 2010 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/Widget
 */
(function(b) {
    var j = b.fn.remove; b.fn.remove = function(a, c) { return this.each(function() { if (!c) if (!a || b.filter(a, [this]).length) b("*", this).add(this).each(function() { b(this).triggerHandler("remove") }); return j.call(b(this), a, c) }) }; b.widget = function(a, c, d) {
        var e = a.split(".")[0], f; a = a.split(".")[1]; f = e + "-" + a; if (!d) { d = c; c = b.Widget } b.expr[":"][f] = function(h) { return !!b.data(h, a) }; b[e] = b[e] || {}; b[e][a] = function(h, g) { arguments.length && this._createWidget(h, g) }; c = new c; c.options = b.extend({}, c.options); b[e][a].prototype =
b.extend(true, c, { namespace: e, widgetName: a, widgetEventPrefix: b[e][a].prototype.widgetEventPrefix || a, widgetBaseClass: f }, d); b.widget.bridge(a, b[e][a])
    }; b.widget.bridge = function(a, c) {
        b.fn[a] = function(d) {
            var e = typeof d === "string", f = Array.prototype.slice.call(arguments, 1), h = this; d = !e && f.length ? b.extend.apply(null, [true, d].concat(f)) : d; if (e && d.substring(0, 1) === "_") return h; e ? this.each(function() { var g = b.data(this, a), i = g && b.isFunction(g[d]) ? g[d].apply(g, f) : g; if (i !== g && i !== undefined) { h = i; return false } }) : this.each(function() {
                var g =
b.data(this, a); if (g) { d && g.option(d); g._init() } else b.data(this, a, new c(d, this))
            }); return h
        }
    }; b.Widget = function(a, c) { arguments.length && this._createWidget(a, c) }; b.Widget.prototype = { widgetName: "widget", widgetEventPrefix: "", options: { disabled: false }, _createWidget: function(a, c) {
        this.element = b(c).data(this.widgetName, this); this.options = b.extend(true, {}, this.options, b.metadata && b.metadata.get(c)[this.widgetName], a); var d = this; this.element.bind("remove." + this.widgetName, function() { d.destroy() }); this._create();
        this._init()
    }, _create: function() { }, _init: function() { }, destroy: function() { this.element.unbind("." + this.widgetName).removeData(this.widgetName); this.widget().unbind("." + this.widgetName).removeAttr("aria-disabled").removeClass(this.widgetBaseClass + "-disabled ui-state-disabled") }, widget: function() { return this.element }, option: function(a, c) {
        var d = a, e = this; if (arguments.length === 0) return b.extend({}, e.options); if (typeof a === "string") { if (c === undefined) return this.options[a]; d = {}; d[a] = c } b.each(d, function(f,
h) { e._setOption(f, h) }); return e
    }, _setOption: function(a, c) { this.options[a] = c; if (a === "disabled") this.widget()[c ? "addClass" : "removeClass"](this.widgetBaseClass + "-disabled ui-state-disabled").attr("aria-disabled", c); return this }, enable: function() { return this._setOption("disabled", false) }, disable: function() { return this._setOption("disabled", true) }, _trigger: function(a, c, d) {
        var e = this.options[a]; c = b.Event(c); c.type = (a === this.widgetEventPrefix ? a : this.widgetEventPrefix + a).toLowerCase(); d = d || {}; if (c.originalEvent) {
            a =
b.event.props.length; for (var f; a; ) { f = b.event.props[--a]; c[f] = c.originalEvent[f] }
        } this.element.trigger(c, d); return !(b.isFunction(e) && e.call(this.element[0], c, d) === false || c.isDefaultPrevented())
    } 
    }
})(jQuery);
; /*!
 * jQuery UI Mouse 1.8.1
 *
 * Copyright (c) 2010 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/Mouse
 *
 * Depends:
 *	jquery.ui.widget.js
 */
(function(c) {
    c.widget("ui.mouse", { options: { cancel: ":input,option", distance: 1, delay: 0 }, _mouseInit: function() { var a = this; this.element.bind("mousedown." + this.widgetName, function(b) { return a._mouseDown(b) }).bind("click." + this.widgetName, function(b) { if (a._preventClickEvent) { a._preventClickEvent = false; b.stopImmediatePropagation(); return false } }); this.started = false }, _mouseDestroy: function() { this.element.unbind("." + this.widgetName) }, _mouseDown: function(a) {
        a.originalEvent = a.originalEvent || {}; if (!a.originalEvent.mouseHandled) {
            this._mouseStarted &&
this._mouseUp(a); this._mouseDownEvent = a; var b = this, e = a.which == 1, f = typeof this.options.cancel == "string" ? c(a.target).parents().add(a.target).filter(this.options.cancel).length : false; if (!e || f || !this._mouseCapture(a)) return true; this.mouseDelayMet = !this.options.delay; if (!this.mouseDelayMet) this._mouseDelayTimer = setTimeout(function() { b.mouseDelayMet = true }, this.options.delay); if (this._mouseDistanceMet(a) && this._mouseDelayMet(a)) {
                this._mouseStarted = this._mouseStart(a) !== false; if (!this._mouseStarted) {
                    a.preventDefault();
                    return true
                }
            } this._mouseMoveDelegate = function(d) { return b._mouseMove(d) }; this._mouseUpDelegate = function(d) { return b._mouseUp(d) }; c(document).bind("mousemove." + this.widgetName, this._mouseMoveDelegate).bind("mouseup." + this.widgetName, this._mouseUpDelegate); c.browser.safari || a.preventDefault(); return a.originalEvent.mouseHandled = true
        }
    }, _mouseMove: function(a) {
        if (c.browser.msie && !a.button) return this._mouseUp(a); if (this._mouseStarted) { this._mouseDrag(a); return a.preventDefault() } if (this._mouseDistanceMet(a) &&
this._mouseDelayMet(a)) (this._mouseStarted = this._mouseStart(this._mouseDownEvent, a) !== false) ? this._mouseDrag(a) : this._mouseUp(a); return !this._mouseStarted
    }, _mouseUp: function(a) { c(document).unbind("mousemove." + this.widgetName, this._mouseMoveDelegate).unbind("mouseup." + this.widgetName, this._mouseUpDelegate); if (this._mouseStarted) { this._mouseStarted = false; this._preventClickEvent = a.target == this._mouseDownEvent.target; this._mouseStop(a) } return false }, _mouseDistanceMet: function(a) {
        return Math.max(Math.abs(this._mouseDownEvent.pageX -
a.pageX), Math.abs(this._mouseDownEvent.pageY - a.pageY)) >= this.options.distance
    }, _mouseDelayMet: function() { return this.mouseDelayMet }, _mouseStart: function() { }, _mouseDrag: function() { }, _mouseStop: function() { }, _mouseCapture: function() { return true }
    })
})(jQuery);
; /*
 * jQuery UI Slider 1.8.1
 *
 * Copyright (c) 2010 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:
 *	jquery.ui.core.js
 *	jquery.ui.mouse.js
 *	jquery.ui.widget.js
 */
/*
* jQuery UI Slider 1.8.1
*
* Copyright (c) 2010 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:
*	jquery.ui.core.js
*	jquery.ui.mouse.js
*	jquery.ui.widget.js
*/

(function($) {

    // 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: {
            animate: false,
            distance: 0,
            max: 100,
            min: 0,
            orientation: "horizontal",
            range: false,
            step: 1,
            value: 0,
            values: null
        },

        _create: function() {
            var self = this,
			o = 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 !== 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,
					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._start(event, index);
			                if (allowed === false) {
			                    return;
			                }
			            }
			            break;
			    }

			    step = self.options.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.PAGE_UP:
			            newVal = curVal + ((self._valueMax() - self._valueMin()) / numPages);
			            break;
			        case $.ui.keyCode.PAGE_DOWN:
			            newVal = curVal - ((self._valueMax() - self._valueMin()) / numPages);
			            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._keySliding = false;
			        self._stop(event, index);
			        self._change(event, index);
			        $(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 o = this.options,
			position,
			normValue,
			distance,
			closestHandle,
			self,
			index,
			allowed,
			offset,
			mouseOverHandle;

            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;
            self = this;
            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) {
                index += 1;
                closestHandle = $(this.handles[index]);
            }

            allowed = this._start(event, index);
            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 ? { 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);
            this._animateOff = true;
            return true;
        },

        _mouseStart: function(event) {
            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();
                }

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

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

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

            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 ($.isArray(this.options.values)) {
                valsLength = this.options.values.length;
            }

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

            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._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;
            }
        },

        //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 {
                // .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;
            }
        },

        // 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,
			valModStep = val % step,
			alignValue = val - valModStep;

            if (valModStep >= (step / 2)) {
                alignValue += 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 oRange = this.options.range,
			o = this.options,
			self = this,
			animate = (!this._animateOff) ? o.animate : false,
			valPercent,
			_set = {},
			lastValPercent,
			value,
			valueMin,
			valueMax;
            value = this.value();
            valueMin = this._valueMin();
            valueMax = this._valueMax();
            valPercent = (valueMax !== valueMin) ?
                (value - valueMin) / (valueMax - valueMin) * 100 :
            0;
            _set[self.orientation === "horizontal" ? "left" : "bottom"] = valPercent + "%";
            this.handle.stop(1, 1)[animate ? "animate" : "animate"](_set, o.animate);
        }

    });

    $.extend($.ui.slider, {
        version: "1.8.1"
    });

} (jQuery));