var baseUrl = "jetbul.com";
function eraseCookie(name) {
	createCookie(name, "", -1);
}
function submitenter(myfield, e,formId) {
	var keycode;
	if (window.event)
		keycode = window.event.keyCode;
	else if (e)
		keycode = e.which;
	else
		return true;

	if (keycode == 13) {
		
		 $('#'+formId).submit();
		return false;
	} else
		return true;
}

function createCookie(name, value, days) {
	if (days) {
		var date = new Date();
		date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
		var expires = "; expires=" + date.toGMTString();
	} else
		expires = "";
	document.cookie = name + "=" + value + expires + "; path=/ ; domain=."
			+ baseUrl;
}
function createCookieTime(name, value, second) {
	if (second) {
		var date = new Date();
		date.setTime(date.getTime() + (second * 1000));
		var expires = "; expires=" + date.toGMTString();
	} else
		expires = "";
	document.cookie = name + "=" + value + expires + "; path=/ ; domain=."
			+ baseUrl;
}
function updateEmlak(eid) {
	$.post('/emlakjax/basic/yenile/', {
		eid : eid
	}, function(msg) {
		$('#hatali' + eid).html("Bildirim için teşekkürler");
	});
}
function addCommas(nStr)
{
	nStr += '';
	x = nStr.split('.');
	x1 = x[0];
	x2 = x.length > 1 ? '.' + x[1] : '';
	var rgx = /(\d+)(\d{3})/;
	while (rgx.test(x1)) {
		x1 = x1.replace(rgx, '$1' + ',' + '$2');
	}
	return x1 + x2;
}

jQuery.ui
		|| (function($) {

			var _remove = $.fn.remove, isFF2 = $.browser.mozilla
					&& (parseFloat($.browser.version) < 1.9);

			// Helper functions and ui object
			$.ui = {
				version : "1.7.2",

				// $.ui.plugin is deprecated. Use the proxy pattern instead.
				plugin : {
					add : function(module, option, set) {
						var proto = $.ui[module].prototype;
						for ( var i in set) {
							proto.plugins[i] = proto.plugins[i] || [];
							proto.plugins[i].push( [ option, set[i] ]);
						}
					},
					call : function(instance, name, args) {
						var set = instance.plugins[name];
						if (!set || !instance.element[0].parentNode) {
							return;
						}

						for ( var i = 0; i < set.length; i++) {
							if (instance.options[set[i][0]]) {
								set[i][1].apply(instance.element, args);
							}
						}
					}
				},

				contains : function(a, b) {
					return document.compareDocumentPosition ? a
							.compareDocumentPosition(b) & 16 : a !== b
							&& a.contains(b);
				},

				hasScroll : function(el, a) {

					// If overflow is hidden, the element might have extra
					// content, but the user wants to hide it
				if ($(el).css('overflow') == 'hidden') {
					return false;
				}

				var scroll = (a && a == 'left') ? 'scrollLeft' : 'scrollTop', has = false;

				if (el[scroll] > 0) {
					return true;
				}

				// TODO: determine which cases actually cause this to happen
				// if the element doesn't have the scroll set, see if it's
				// possible to
				// set the scroll
				el[scroll] = 1;
				has = (el[scroll] > 0);
				el[scroll] = 0;
				return has;
			},

			isOverAxis : function(x, reference, size) {
				// Determines when x coordinate is over "b" element axis
				return (x > reference) && (x < (reference + size));
			},

			isOver : function(y, x, top, left, height, width) {
				// Determines when x, y coordinates is over "b" element
				return $.ui.isOverAxis(y, top, height)
						&& $.ui.isOverAxis(x, left, width);
			},

			keyCode : {
				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
			}
			};

			// WAI-ARIA normalization
			if (isFF2) {
				var attr = $.attr, removeAttr = $.fn.removeAttr, ariaNS = "http://www.w3.org/2005/07/aaa", ariaState = /^aria-/, ariaRole = /^wairole:/;

				$.attr = function(elem, name, value) {
					var set = value !== undefined;

					return (name == 'role' ? (set ? attr.call(this, elem, name,
							"wairole:" + value)
							: (attr.apply(this, arguments) || "").replace(
									ariaRole, ""))
							: (ariaState.test(name) ? (set ? elem
									.setAttributeNS(ariaNS, name.replace(
											ariaState, "aaa:"), value) : attr
									.call(this, elem, name.replace(ariaState,
											"aaa:"))) : attr.apply(this,
									arguments)));
				};

				$.fn.removeAttr = function(name) {
					return (ariaState.test(name) ? this.each(function() {
						this.removeAttributeNS(ariaNS, name.replace(ariaState,
								""));
					}) : removeAttr.call(this, name));
				};
			}

			// jQuery plugins
			$.fn.extend( {
				remove : function() {
					// Safari has a native remove event which actually removes
					// DOM elements,
					// so we have to use triggerHandler instead of trigger
					// (#3037).
					$("*", this).add(this).each(function() {
						$(this).triggerHandler("remove");
					});
					return _remove.apply(this, arguments);
				},

				enableSelection : function() {
					return this.attr('unselectable', 'off').css(
							'MozUserSelect', '').unbind('selectstart.ui');
				},

				disableSelection : function() {
					return this.attr('unselectable', 'on').css('MozUserSelect',
							'none').bind('selectstart.ui', function() {
						return false;
					});
				},

				scrollParent : function() {
					var scrollParent;
					if (($.browser.msie && (/(static|relative)/).test(this
							.css('position')))
							|| (/absolute/).test(this.css('position'))) {
						scrollParent = this.parents().filter(
								function() {
									return (/(relative|absolute|fixed)/).test($
											.curCSS(this, 'position', 1))
											&& (/(auto|scroll)/).test($.curCSS(
													this, 'overflow', 1)
													+ $.curCSS(this,
															'overflow-y', 1)
													+ $.curCSS(this,
															'overflow-x', 1));
								}).eq(0);
					} else {
						scrollParent = this.parents().filter(
								function() {
									return (/(auto|scroll)/).test($.curCSS(
											this, 'overflow', 1)
											+ $.curCSS(this, 'overflow-y', 1)
											+ $.curCSS(this, 'overflow-x', 1));
								}).eq(0);
					}

					return (/fixed/).test(this.css('position'))
							|| !scrollParent.length ? $(document)
							: scrollParent;
				}
			});

			// Additional selectors
			$
					.extend(
							$.expr[':'],
							{
								data : function(elem, i, match) {
									return !!$.data(elem, match[3]);
								},

								focusable : function(element) {
									var nodeName = element.nodeName
											.toLowerCase(), tabIndex = $.attr(
											element, 'tabindex');
									return (/input|select|textarea|button|object/
											.test(nodeName) ? !element.disabled
											: 'a' == nodeName
													|| 'area' == nodeName ? element.href
													|| !isNaN(tabIndex)
													: !isNaN(tabIndex))
											// the element and all of its
											// ancestors must be visible
											// the browser may report that the
											// area is hidden
											&& !$(element)['area' == nodeName ? 'parents'
													: 'closest'](':hidden').length;
								},

								tabbable : function(element) {
									var tabIndex = $.attr(element, 'tabindex');
									return (isNaN(tabIndex) || tabIndex >= 0)
											&& $(element).is(':focusable');
								}
							});

			// $.widget is a factory to create jQuery plugins
			// taking some boilerplate code out of the plugin code
			function getter(namespace, plugin, method, args) {
				function getMethods(type) {
					var methods = $[namespace][plugin][type] || [];
					return (typeof methods == 'string' ? methods.split(/,?\s+/)
							: methods);
				}

				var methods = getMethods('getter');
				if (args.length == 1 && typeof args[0] == 'string') {
					methods = methods.concat(getMethods('getterSetter'));
				}
				return ($.inArray(method, methods) != -1);
			}

			$.widget = function(name, prototype) {
				var namespace = name.split(".")[0];
				name = name.split(".")[1];

				// create plugin method
				$.fn[name] = function(options) {
					var isMethodCall = (typeof options == 'string'), args = Array.prototype.slice
							.call(arguments, 1);

					// prevent calls to internal methods
					if (isMethodCall && options.substring(0, 1) == '_') {
						return this;
					}

					// handle getter methods
					if (isMethodCall && getter(namespace, name, options, args)) {
						var instance = $.data(this[0], name);
						return (instance ? instance[options].apply(instance,
								args) : undefined);
					}

					// handle initialization and non-getter methods
					return this.each(function() {
						var instance = $.data(this, name);

						// constructor
							(!instance && !isMethodCall && $.data(this, name,
									new $[namespace][name](this, options))
									._init());

							// method call
							(instance && isMethodCall
									&& $.isFunction(instance[options]) && instance[options]
									.apply(instance, args));
						});
				};

				// create widget constructor
				$[namespace] = $[namespace] || {};
				$[namespace][name] = function(element, options) {
					var self = this;

					this.namespace = namespace;
					this.widgetName = name;
					this.widgetEventPrefix = $[namespace][name].eventPrefix
							|| name;
					this.widgetBaseClass = namespace + '-' + name;

					this.options = $.extend( {}, $.widget.defaults,
							$[namespace][name].defaults, $.metadata
									&& $.metadata.get(element)[name], options);

					this.element = $(element).bind('setData.' + name,
							function(event, key, value) {
								if (event.target == element) {
									return self._setData(key, value);
								}
							}).bind('getData.' + name, function(event, key) {
						if (event.target == element) {
							return self._getData(key);
						}
					}).bind('remove', function() {
						return self.destroy();
					});
				};

				// add widget prototype
				$[namespace][name].prototype = $.extend( {},
						$.widget.prototype, prototype);

				// TODO: merge getter and getterSetter properties from widget
				// prototype
				// and plugin prototype
				$[namespace][name].getterSetter = 'option';
			};

			$.widget.prototype = {
				_init : function() {
				},
				destroy : function() {
					this.element.removeData(this.widgetName).removeClass(
							this.widgetBaseClass + '-disabled' + ' '
									+ this.namespace + '-state-disabled')
							.removeAttr('aria-disabled');
				},

				option : function(key, value) {
					var options = key, self = this;

					if (typeof key == "string") {
						if (value === undefined) {
							return this._getData(key);
						}
						options = {};
						options[key] = value;
					}

					$.each(options, function(key, value) {
						self._setData(key, value);
					});
				},
				_getData : function(key) {
					return this.options[key];
				},
				_setData : function(key, value) {
					this.options[key] = value;

					if (key == 'disabled') {
						this.element[value ? 'addClass' : 'removeClass'](
								this.widgetBaseClass + '-disabled' + ' '
										+ this.namespace + '-state-disabled')
								.attr("aria-disabled", value);
					}
				},

				enable : function() {
					this._setData('disabled', false);
				},
				disable : function() {
					this._setData('disabled', true);
				},

				_trigger : function(type, event, data) {
					var callback = this.options[type], eventName = (type == this.widgetEventPrefix ? type
							: this.widgetEventPrefix + type);

					event = $.Event(event);
					event.type = eventName;

					// copy original event properties over to the new event
					// this would happen if we could call $.event.fix instead of
					// $.Event
					// but we don't have a way to force an event to be fixed
					// multiple times
					if (event.originalEvent) {
						for ( var i = $.event.props.length, prop; i;) {
							prop = $.event.props[--i];
							event[prop] = event.originalEvent[prop];
						}
					}

					this.element.trigger(event, data);

					return !($.isFunction(callback)
							&& callback.call(this.element[0], event, data) === false || event
							.isDefaultPrevented());
				}
			};

			$.widget.defaults = {
				disabled : false
			};

			/** Mouse Interaction Plugin * */

			$.ui.mouse = {
				_mouseInit : function() {
					var self = this;

					this.element.bind('mousedown.' + this.widgetName,
							function(event) {
								return self._mouseDown(event);
							}).bind('click.' + this.widgetName,
							function(event) {
								if (self._preventClickEvent) {
									self._preventClickEvent = false;
									event.stopImmediatePropagation();
									return false;
								}
							});

					// Prevent text selection in IE
					if ($.browser.msie) {
						this._mouseUnselectable = this.element
								.attr('unselectable');
						this.element.attr('unselectable', 'on');
					}

					this.started = false;
				},

				// TODO: make sure destroying one instance of mouse doesn't mess
				// with
				// other instances of mouse
				_mouseDestroy : function() {
					this.element.unbind('.' + this.widgetName);

					// Restore text selection in IE
					($.browser.msie && this.element.attr('unselectable',
							this._mouseUnselectable));
				},

				_mouseDown : function(event) {
					// don't let more than one widget handle mouseStart
					// TODO: figure out why we have to use originalEvent
					event.originalEvent = event.originalEvent || {};
					if (event.originalEvent.mouseHandled) {
						return;
					}

					// we may have missed mouseup (out of window)
					(this._mouseStarted && this._mouseUp(event));

					this._mouseDownEvent = event;

					var self = this, btnIsLeft = (event.which == 1), elIsCancel = (typeof this.options.cancel == "string" ? $(
							event.target).parents().add(event.target).filter(
							this.options.cancel).length
							: false);
					if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
						return true;
					}

					this.mouseDelayMet = !this.options.delay;
					if (!this.mouseDelayMet) {
						this._mouseDelayTimer = setTimeout(function() {
							self.mouseDelayMet = true;
						}, this.options.delay);
					}

					if (this._mouseDistanceMet(event)
							&& this._mouseDelayMet(event)) {
						this._mouseStarted = (this._mouseStart(event) !== false);
						if (!this._mouseStarted) {
							event.preventDefault();
							return true;
						}
					}

					// these delegates are required to keep context
					this._mouseMoveDelegate = function(event) {
						return self._mouseMove(event);
					};
					this._mouseUpDelegate = function(event) {
						return self._mouseUp(event);
					};
					$(document).bind('mousemove.' + this.widgetName,
							this._mouseMoveDelegate)
							.bind('mouseup.' + this.widgetName,
									this._mouseUpDelegate);

					// preventDefault() is used to prevent the selection of text
					// here -
					// however, in Safari, this causes select boxes not to be
					// selectable
					// anymore, so this fix is needed
					($.browser.safari || event.preventDefault());

					event.originalEvent.mouseHandled = true;
					return true;
				},

				_mouseMove : function(event) {
					// IE mouseup check - mouseup happened when mouse was out of
					// window
					if ($.browser.msie && !event.button) {
						return this._mouseUp(event);
					}

					if (this._mouseStarted) {
						this._mouseDrag(event);
						return event.preventDefault();
					}

					if (this._mouseDistanceMet(event)
							&& this._mouseDelayMet(event)) {
						this._mouseStarted = (this._mouseStart(
								this._mouseDownEvent, event) !== false);
						(this._mouseStarted ? this._mouseDrag(event) : this
								._mouseUp(event));
					}

					return !this._mouseStarted;
				},

				_mouseUp : function(event) {
					$(document).unbind('mousemove.' + this.widgetName,
							this._mouseMoveDelegate)
							.unbind('mouseup.' + this.widgetName,
									this._mouseUpDelegate);

					if (this._mouseStarted) {
						this._mouseStarted = false;
						this._preventClickEvent = (event.target == this._mouseDownEvent.target);
						this._mouseStop(event);
					}

					return false;
				},

				_mouseDistanceMet : function(event) {
					return (Math.max(Math.abs(this._mouseDownEvent.pageX
							- event.pageX), Math.abs(this._mouseDownEvent.pageY
							- event.pageY)) >= this.options.distance);
				},

				_mouseDelayMet : function(event) {
					return this.mouseDelayMet;
				},

				// These are placeholder methods, to be overriden by extending
				// plugin
				_mouseStart : function(event) {
				},
				_mouseDrag : function(event) {
				},
				_mouseStop : function(event) {
				},
				_mouseCapture : function(event) {
					return true;
				}
			};

			$.ui.mouse.defaults = {
				cancel : null,
				distance : 1,
				delay : 0
			};

		})(jQuery);
/*
 * 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);
													}
												}

											} else {

												if (newVal != this.value()) {
													// A slide can be canceled
													// by returning false from
													// the slide callback
													var allowed = this
															._trigger(
																	"slide",
																	event,
																	{
																		handle : this.handles[index],
																		value : newVal
																	});
													if (allowed !== false) {
														this
																._setData(
																		'value',
																		newVal,
																		(event.type == 'mousedown' && this.options.animate));
													}

												}

											}

										},

										_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) {
											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
														._setData("value",
																newValue);
												this._change(null, 0);
											}

											return this._value();

										},

										values : function(index, newValue,
												animated, noPropagation) {

											if (arguments.length > 1) {
												this.options.values[index] = newValue;
												this._refreshValue(animated);
												if (!noPropagation)
													this._change(null, index);
											}

											if (arguments.length) {
												if (this.options.values
														&& this.options.values.length) {
													return this._values(index);
												} else {
													return this.value();
												}
											} else {
												return this._values();
											}

										},

										_setData : function(key, value,
												animated) {

											$.widget.prototype._setData.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");
												} else {
													this.handles
															.removeAttr("disabled");
												}
											case 'orientation':

												this._detectOrientation();

												this.element
														.removeClass(
																"ui-slider-horizontal ui-slider-vertical")
														.addClass(
																"ui-slider-"
																		+ this.orientation);
												this._refreshValue(animated);
												break;
											case 'value':
												this._refreshValue(animated);
												break;
											}

										},

										_step : function() {
											var step = this.options.step;
											return step;
										},

										_value : function() {

											var val = this.options.value;
											if (val < this._valueMin())
												val = this._valueMin();
											if (val > this._valueMax())
												val = this._valueMax();

											return val;

										},

										_values : function(index) {

											if (arguments.length) {
												var val = this.options.values[index];
												if (val < this._valueMin())
													val = this._valueMin();
												if (val > this._valueMax())
													val = this._valueMax();

												return val;
											} else {
												return this.options.values;
											}

										},

										_valueMin : function() {
											var valueMin = this.options.min;
											return valueMin;
										},

										_valueMax : function() {
											var valueMax = this.options.max;
											return valueMax;
										},

										_refreshValue : function(animate) {

											var oRange = this.options.range, o = this.options, self = this;

											if (this.options.values
													&& this.options.values.length) {
												var vp0, vp1;
												this.handles
														.each(function(i, j) {
															var valPercent = (self
																	.values(i) - self
																	._valueMin())
																	/ (self
																			._valueMax() - self
																			._valueMin())
																	* 100;
															var _set = {};
															_set[self.orientation == 'horizontal' ? 'left'
																	: 'bottom'] = valPercent + '%';
															$(this).stop(1, 1)[animate ? 'animate'
																	: 'css'](
																	_set,
																	o.animate);
															if (self.options.range === true) {
																if (self.orientation == 'horizontal') {
																	(i == 0)
																			&& self.range
																					.stop(
																							1,
																							1)[animate ? 'animate'
																					: 'css']
																					(
																							{
																								left : valPercent + '%'
																							},
																							o.animate);
																	(i == 1)
																			&& self.range[animate ? 'animate'
																					: 'css']
																					(
																							{
																								width : (valPercent - lastValPercent) + '%'
																							},
																							{
																								queue : false,
																								duration : o.animate
																							});
																} else {
																	(i == 0)
																			&& self.range
																					.stop(
																							1,
																							1)[animate ? 'animate'
																					: 'css']
																					(
																							{
																								bottom : (valPercent) + '%'
																							},
																							o.animate);
																	(i == 1)
																			&& self.range[animate ? 'animate'
																					: 'css']
																					(
																							{
																								height : (valPercent - lastValPercent) + '%'
																							},
																							{
																								queue : false,
																								duration : o.animate
																							});
																}
															}
															lastValPercent = valPercent;
														});
											} else {
												var value = this.value(), valueMin = this
														._valueMin(), valueMax = this
														._valueMax(), valPercent = valueMax != valueMin ? (value - valueMin)
														/ (valueMax - valueMin)
														* 100
														: 0;
												var _set = {};
												_set[self.orientation == 'horizontal' ? 'left'
														: 'bottom'] = valPercent + '%';
												this.handle.stop(1, 1)[animate ? 'animate'
														: 'css'](_set,
														o.animate);

												(oRange == "min")
														&& (this.orientation == "horizontal")
														&& this.range
																.stop(1, 1)[animate ? 'animate'
																: 'css']
																(
																		{
																			width : valPercent + '%'
																		},
																		o.animate);
												(oRange == "max")
														&& (this.orientation == "horizontal")
														&& this.range[animate ? 'animate'
																: 'css']
																(
																		{
																			width : (100 - valPercent) + '%'
																		},
																		{
																			queue : false,
																			duration : o.animate
																		});
												(oRange == "min")
														&& (this.orientation == "vertical")
														&& this.range
																.stop(1, 1)[animate ? 'animate'
																: 'css']
																(
																		{
																			height : valPercent + '%'
																		},
																		o.animate);
												(oRange == "max")
														&& (this.orientation == "vertical")
														&& this.range[animate ? 'animate'
																: 'css']
																(
																		{
																			height : (100 - valPercent) + '%'
																		},
																		{
																			queue : false,
																			duration : o.animate
																		});
											}

										}

									}));

	$.extend($.ui.slider, {
		getter : "value values",
		version : "1.7.2",
		eventPrefix : "slide",
		defaults : {
			animate : false,
			delay : 0,
			distance : 0,
			max : 100,
			min : 0,
			orientation : 'horizontal',
			range : false,
			step : 1,
			value : 0,
			values : null
		}
	});

})(jQuery);