diff --git a/css/main.css b/css/main.css
index 5b3ec6d8453bde624f2632f016a883a755cd5b9a..bf1d346c35eb93629ef0dc1785e5c977650a9a8d 100644
--- a/css/main.css
+++ b/css/main.css
@@ -63,3 +63,17 @@ nav .btn {
     position: relative;
     overflow: hidden;
 }
+
+.fullWidth {
+    width: 100%!important;
+}
+
+/*import menu*/
+
+#ex1Slider .slider-selection {
+	background: #BABABA;
+}
+
+#STLImportStats {
+    display: none;
+}
\ No newline at end of file
diff --git a/dependencies/bootstrap-slider/bootstrap-slider.css b/dependencies/bootstrap-slider/bootstrap-slider.css
new file mode 100755
index 0000000000000000000000000000000000000000..043a23414ea5eff21cd4a2f48870868cbfc86ef3
--- /dev/null
+++ b/dependencies/bootstrap-slider/bootstrap-slider.css
@@ -0,0 +1,164 @@
+/*! =========================================================
+ * 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.
+ * ========================================================= */
+.slider {
+  display: inline-block;
+  vertical-align: middle;
+  position: relative;
+}
+.slider.slider-horizontal {
+  width: 210px;
+  height: 20px;
+}
+.slider.slider-horizontal .slider-track {
+  height: 10px;
+  width: 100%;
+  margin-top: -5px;
+  top: 50%;
+  left: 0;
+}
+.slider.slider-horizontal .slider-selection {
+  height: 100%;
+  top: 0;
+  bottom: 0;
+}
+.slider.slider-horizontal .slider-handle {
+  margin-left: -10px;
+  margin-top: -5px;
+}
+.slider.slider-horizontal .slider-handle.triangle {
+  border-width: 0 10px 10px 10px;
+  width: 0;
+  height: 0;
+  border-bottom-color: #1abc9c;
+  margin-top: 0;
+}
+.slider.slider-vertical {
+  height: 210px;
+  width: 20px;
+}
+.slider.slider-vertical .slider-track {
+  width: 10px;
+  height: 100%;
+  margin-left: -5px;
+  left: 50%;
+  top: 0;
+}
+.slider.slider-vertical .slider-selection {
+  width: 100%;
+  left: 0;
+  top: 0;
+  bottom: 0;
+}
+.slider.slider-vertical .slider-handle {
+  margin-left: -5px;
+  margin-top: -10px;
+}
+.slider.slider-vertical .slider-handle.triangle {
+  border-width: 10px 0 10px 10px;
+  width: 1px;
+  height: 1px;
+  border-left-color: #1abc9c;
+  margin-left: 0;
+}
+.slider.slider-disabled .slider-handle {
+  background-image: -webkit-linear-gradient(top, #dfdfdf 0%, #bebebe 100%);
+  background-image: linear-gradient(to bottom, #dfdfdf 0%, #bebebe 100%);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdfdfdf', endColorstr='#ffbebebe', GradientType=0);
+}
+.slider.slider-disabled .slider-track {
+  background-image: -webkit-linear-gradient(top, #e5e5e5 0%, #e9e9e9 100%);
+  background-image: linear-gradient(to bottom, #e5e5e5 0%, #e9e9e9 100%);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffe5e5e5', endColorstr='#ffe9e9e9', GradientType=0);
+  cursor: not-allowed;
+}
+.slider input {
+  display: none;
+}
+.slider .tooltip.top {
+  margin-top: -36px;
+}
+.slider .tooltip-inner {
+  white-space: nowrap;
+}
+.slider .hide {
+  display: none;
+}
+.slider-track {
+  position: absolute;
+  cursor: pointer;
+  background-image: -webkit-linear-gradient(top, #f5f5f5 0%, #f9f9f9 100%);
+  background-image: linear-gradient(to bottom, #f5f5f5 0%, #f9f9f9 100%);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  border-radius: 4px;
+}
+.slider-selection {
+  position: absolute;
+  background-image: -webkit-linear-gradient(top, #f9f9f9 0%, #f5f5f5 100%);
+  background-image: linear-gradient(to bottom, #f9f9f9 0%, #f5f5f5 100%);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff9f9f9', endColorstr='#fff5f5f5', GradientType=0);
+  -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  border-radius: 4px;
+}
+.slider-handle {
+  position: absolute;
+  width: 20px;
+  height: 20px;
+  background-color: #3a94a5;
+  background-image: -webkit-linear-gradient(top, #1abc9c 0%, #1abc9c 100%);
+  background-image: linear-gradient(to bottom, #1abc9c 0%, #1abc9c 100%);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);
+  filter: none;
+  -webkit-box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  opacity: 0.8;
+  border: 0px solid transparent;
+}
+.slider-handle.round {
+  border-radius: 50%;
+}
+.slider-handle.triangle {
+  background: transparent none;
+}
+.slider-handle.custom {
+  background: transparent none;
+}
+.slider-handle.custom::before {
+  line-height: 20px;
+  font-size: 20px;
+  content: '\2605';
+  color: #726204;
+}
diff --git a/dependencies/bootstrap-slider/bootstrap-slider.js b/dependencies/bootstrap-slider/bootstrap-slider.js
new file mode 100755
index 0000000000000000000000000000000000000000..ccb3c42039d864345bf72d1be3e35a6fa95dc79b
--- /dev/null
+++ b/dependencies/bootstrap-slider/bootstrap-slider.js
@@ -0,0 +1,1210 @@
+/*! =========================================================
+ * 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) {
+			/*************************************************
+
+							Create Markup
+
+			**************************************************/
+			if(typeof element === "string") {
+				this.element = document.querySelector(element);
+			} else if(element instanceof HTMLElement) {
+				this.element = element;
+			}
+
+			var origWidth = this.element.style.width;
+			var updateSlider = false;
+			var parent = this.element.parentNode;
+			var sliderTrackSelection;
+			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";
+
+				sliderTrackSelection = document.createElement("div");
+				sliderTrackSelection.className = "slider-selection";
+
+				sliderMinHandle = document.createElement("div");
+				sliderMinHandle.className = "slider-handle min-slider-handle";
+
+				sliderMaxHandle = document.createElement("div");
+				sliderMaxHandle.className = "slider-handle max-slider-handle";
+
+				sliderTrack.appendChild(sliderTrackSelection);
+				sliderTrack.appendChild(sliderMinHandle);
+				sliderTrack.appendChild(sliderMaxHandle);
+
+				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);
+
+				/* 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);
+			}
+
+			/*************************************************
+
+							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;
+				}
+			}
+
+			/*************************************************
+
+								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.trackSelection, 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._addClass(this.sliderElem, 'fullWidth');
+				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';
+			}
+
+			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.trackSelection = sliderTrackSelection || this.trackSelection;
+			if (this.options.selection === 'none') {
+				this._addClass(this.trackSelection, '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');
+			}
+
+			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);
+			}
+
+			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,
+				formatter: function(val) {
+					if(val instanceof Array) {
+						return val[0] + " : " + val[1];
+					} else {
+						return val;
+					}
+				},
+				natural_arrow_keys: false
+			},
+
+			over: false,
+
+			inDrag: false,
+
+			getValue: function() {
+				if (this.options.range) {
+					return this.options.value;
+				}
+				return this.options.value[0];
+			},
+
+			setValue: function(val, triggerSlideEvent) {
+				if (!val) {
+					val = 0;
+				}
+				var oldValue = this.getValue();
+				this.options.value = this._validateInputValue(val);
+				var applyPrecision = this._applyPrecision.bind(this);
+
+				if (this.options.range) {
+					this.options.value[0] = applyPrecision(this.options.value[0]);
+					this.options.value[1] = applyPrecision(this.options.value[1]);
+
+					this.options.value[0] = Math.max(this.options.min, Math.min(this.options.max, this.options.value[0]));
+					this.options.value[1] = Math.max(this.options.min, Math.min(this.options.max, this.options.value[1]));
+				} else {
+					this.options.value = applyPrecision(this.options.value);
+					this.options.value = [ Math.max(this.options.min, Math.min(this.options.max, this.options.value))];
+					this._addClass(this.handle2, 'hide');
+					if (this.options.selection === 'after') {
+						this.options.value[1] = this.options.max;
+					} else {
+						this.options.value[1] = this.options.min;
+					}
+				}
+
+				this.diff = this.options.max - this.options.min;
+				if (this.diff > 0) {
+					this.percentage = [
+						(this.options.value[0] - this.options.min) * 100 / this.diff,
+						(this.options.value[1] - this.options.min) * 100 / this.diff,
+						this.options.step * 100 / this.diff
+					];
+				} else {
+					this.percentage = [0, 0, 100];
+				}
+
+				this._layout();
+				var newValue = this.options.range ? this.options.value : this.options.value[0];
+
+				if(triggerSlideEvent === true) {
+					this._trigger('slide', newValue);
+				}
+				if(oldValue !== newValue) {
+					this._trigger('change', {
+						oldValue: oldValue,
+						newValue: newValue
+					});
+				}
+				this._setDataVal(newValue);
+
+				return this;
+			},
+
+			destroy: function(){
+				// Remove event handlers on slider elements
+				this._removeSliderEventHandlers();
+
+				// Remove the slider from the DOM
+				this.sliderElem.parentNode.removeChild(this.sliderElem);
+				/* Show original <input> element */
+				this.element.style.display = "";
+
+				// Clear out custom event bindings
+				this._cleanUpEventCallbacksMap();
+
+				// Remove data values
+				this.element.removeAttribute("data");
+
+				// Remove JQuery handlers/data
+				if($) {
+					this._unbindJQueryEventHandlers();
+					this.$element.removeData('slider');
+				}
+			},
+
+			disable: function() {
+				this.options.enabled = false;
+				this.handle1.removeAttribute("tabindex");
+				this.handle2.removeAttribute("tabindex");
+				this._addClass(this.sliderElem, 'slider-disabled');
+				this._trigger('slideDisabled');
+
+				return this;
+			},
+
+			enable: function() {
+				this.options.enabled = true;
+				this.handle1.setAttribute("tabindex", 0);
+				this.handle2.setAttribute("tabindex", 0);
+				this._removeClass(this.sliderElem, 'slider-disabled');
+				this._trigger('slideEnabled');
+
+				return this;
+			},
+
+			toggle: function() {
+				if(this.options.enabled) {
+					this.disable();
+				} else {
+					this.enable();
+				}
+
+				return this;
+			},
+
+			isEnabled: function() {
+				return this.options.enabled;
+			},
+
+			on: function(evt, callback) {
+				if($) {
+					this.$element.on(evt, callback);
+					this.$sliderElem.on(evt, callback);
+				} else {
+					this._bindNonQueryEventHandler(evt, callback);
+				}
+				return this;
+			},
+
+			getAttribute: function(attribute) {
+				if(attribute) {
+					return this.options[attribute];
+				} else {
+					return this.options;
+				}
+			},
+
+			setAttribute: function(attribute, value) {
+				this.options[attribute] = value;
+				return this;
+			},
+
+			refresh: function() {
+				this._removeSliderEventHandlers();
+				createNewSlider.call(this, this.element, this.options);
+				if($) {
+					// Bind new instance of slider to the element
+					$.data(this.element, 'slider', this);
+				}
+				return this;
+			},
+
+			relayout: function() {
+				this._layout();
+				return this;
+			},
+
+			/******************************+
+
+						HELPERS
+
+			- Any method that is not part of the public interface.
+			- Place it underneath this comment block and write its signature like so:
+
+			  					_fnName : function() {...}
+
+			********************************/
+			_removeSliderEventHandlers: function() {
+				// Remove event listeners from handle1
+				this.handle1.removeEventListener("keydown", this.handle1Keydown, false);
+				this.handle1.removeEventListener("focus", this.showTooltip, false);
+				this.handle1.removeEventListener("blur", this.hideTooltip, false);
+
+				// Remove event listeners from handle2
+				this.handle2.removeEventListener("keydown", this.handle2Keydown, false);
+				this.handle2.removeEventListener("focus", this.handle2Keydown, false);
+				this.handle2.removeEventListener("blur", this.handle2Keydown, false);
+
+				// Remove event listeners from sliderElem
+				this.sliderElem.removeEventListener("mouseenter", this.showTooltip, false);
+				this.sliderElem.removeEventListener("mouseleave", this.hideTooltip, false);
+				this.sliderElem.removeEventListener("touchstart", this.mousedown, false);
+				this.sliderElem.removeEventListener("mousedown", this.mousedown, false);
+			},
+			_bindNonQueryEventHandler: function(evt, callback) {
+				if(this.eventToCallbackMap[evt]===undefined) {
+					this.eventToCallbackMap[evt] = [];
+				}
+				this.eventToCallbackMap[evt].push(callback);
+			},
+			_cleanUpEventCallbacksMap: function() {
+				var eventNames = Object.keys(this.eventToCallbackMap);
+				for(var i = 0; i < eventNames.length; i++) {
+					var eventName = eventNames[i];
+					this.eventToCallbackMap[eventName] = null;
+				}
+			},
+			_showTooltip: function() {
+				if (this.options.tooltip_split === false ){
+	            	this._addClass(this.tooltip, 'in');
+		        } else {
+		            this._addClass(this.tooltip_min, 'in');
+		            this._addClass(this.tooltip_max, 'in');
+		        }
+				this.over = true;
+			},
+			_hideTooltip: function() {
+				if (this.inDrag === false && this.alwaysShowTooltip !== true) {
+					this._removeClass(this.tooltip, 'in');
+					this._removeClass(this.tooltip_min, 'in');
+					this._removeClass(this.tooltip_max, 'in');
+				}
+				this.over = false;
+			},
+			_layout: function() {
+				var positionPercentages;
+
+				if(this.options.reversed) {
+					positionPercentages = [ 100 - this.percentage[0], this.percentage[1] ];
+				} else {
+					positionPercentages = [ this.percentage[0], this.percentage[1] ];
+				}
+
+				this.handle1.style[this.stylePos] = positionPercentages[0]+'%';
+				this.handle2.style[this.stylePos] = positionPercentages[1]+'%';
+
+				if (this.options.orientation === 'vertical') {
+					this.trackSelection.style.top = Math.min(positionPercentages[0], positionPercentages[1]) +'%';
+					this.trackSelection.style.height = Math.abs(positionPercentages[0] - positionPercentages[1]) +'%';
+				} else {
+					this.trackSelection.style.left = Math.min(positionPercentages[0], positionPercentages[1]) +'%';
+					this.trackSelection.style.width = Math.abs(positionPercentages[0] - positionPercentages[1]) +'%';
+
+			        var offset_min = this.tooltip_min.getBoundingClientRect();
+			        var offset_max = this.tooltip_max.getBoundingClientRect();
+
+			        if (offset_min.right > offset_max.left) {
+			            this._removeClass(this.tooltip_max, 'top');
+			            this._addClass(this.tooltip_max, 'bottom');
+			            this.tooltip_max.style.top = 18 + 'px';
+			        } else {
+			            this._removeClass(this.tooltip_max, 'bottom');
+			            this._addClass(this.tooltip_max, 'top');
+			            this.tooltip_max.style.top = -30 + 'px';
+			        }
+	 			}
+
+	 			var formattedTooltipVal;
+
+				if (this.options.range) {
+					formattedTooltipVal = this.options.formatter(this.options.value);
+					this._setText(this.tooltipInner, formattedTooltipVal);
+					this.tooltip.style[this.stylePos] = (positionPercentages[1] + positionPercentages[0])/2 + '%';
+
+					if (this.options.orientation === 'vertical') {
+						this._css(this.tooltip, 'margin-top', -this.tooltip.offsetHeight / 2 + 'px');
+					} else {
+						this._css(this.tooltip, 'margin-left', -this.tooltip.offsetWidth / 2 + 'px');
+					}
+
+					if (this.options.orientation === 'vertical') {
+						this._css(this.tooltip, 'margin-top', -this.tooltip.offsetHeight / 2 + 'px');
+					} else {
+						this._css(this.tooltip, 'margin-left', -this.tooltip.offsetWidth / 2 + 'px');
+					}
+
+					var innerTooltipMinText = this.options.formatter(this.options.value[0]);
+					this._setText(this.tooltipInner_min, innerTooltipMinText);
+
+					var innerTooltipMaxText = this.options.formatter(this.options.value[1]);
+					this._setText(this.tooltipInner_max, innerTooltipMaxText);
+
+					this.tooltip_min.style[this.stylePos] = positionPercentages[0] + '%';
+
+					if (this.options.orientation === 'vertical') {
+						this._css(this.tooltip_min, 'margin-top', -this.tooltip_min.offsetHeight / 2 + 'px');
+					} else {
+						this._css(this.tooltip_min, 'margin-left', -this.tooltip_min.offsetWidth / 2 + 'px');
+					}
+
+					this.tooltip_max.style[this.stylePos] = positionPercentages[1] + '%';
+
+					if (this.options.orientation === 'vertical') {
+						this._css(this.tooltip_max, 'margin-top', -this.tooltip_max.offsetHeight / 2 + 'px');
+					} else {
+						this._css(this.tooltip_max, 'margin-left', -this.tooltip_max.offsetWidth / 2 + 'px');
+					}
+				} else {
+					formattedTooltipVal = this.options.formatter(this.options.value[0]);
+					this._setText(this.tooltipInner, formattedTooltipVal);
+
+					this.tooltip.style[this.stylePos] = positionPercentages[0] + '%';
+					if (this.options.orientation === 'vertical') {
+						this._css(this.tooltip, 'margin-top', -this.tooltip.offsetHeight / 2 + 'px');
+					} else {
+						this._css(this.tooltip, 'margin-left', -this.tooltip.offsetWidth / 2 + 'px');
+					}
+				}
+			},
+			_removeProperty: function(element, prop) {
+				if (element.style.removeProperty) {
+				    element.style.removeProperty(prop);
+				} else {
+				    element.style.removeAttribute(prop);
+				}
+			},
+			_mousedown: function(ev) {
+				if(!this.options.enabled) {
+					return false;
+				}
+
+				this._triggerFocusOnHandle();
+
+				this.offset = this._offset(this.sliderElem);
+				this.size = this.sliderElem[this.sizePos];
+
+				var percentage = this._getPercentage(ev);
+
+				if (this.options.range) {
+					var diff1 = Math.abs(this.percentage[0] - percentage);
+					var diff2 = Math.abs(this.percentage[1] - percentage);
+					this.dragged = (diff1 < diff2) ? 0 : 1;
+				} else {
+					this.dragged = 0;
+				}
+
+				this.percentage[this.dragged] = this.options.reversed ? 100 - percentage : percentage;
+				this._layout();
+
+				if (this.touchCapable) {
+					document.removeEventListener("touchmove", this.mousemove, false);
+					document.removeEventListener("touchend", this.mouseup, false);
+				}
+
+				if(this.mousemove){
+					document.removeEventListener("mousemove", this.mousemove, false);
+				}
+				if(this.mouseup){
+					document.removeEventListener("mouseup", this.mouseup, false);
+				}
+
+				this.mousemove = this._mousemove.bind(this);
+				this.mouseup = this._mouseup.bind(this);
+
+				if (this.touchCapable) {
+					// Touch: Bind touch events:
+					document.addEventListener("touchmove", this.mousemove, false);
+					document.addEventListener("touchend", this.mouseup, false);
+				}
+				// Bind mouse events:
+				document.addEventListener("mousemove", this.mousemove, false);
+				document.addEventListener("mouseup", this.mouseup, false);
+
+				this.inDrag = true;
+				var newValue = this._calculateValue();
+
+				this._trigger('slideStart', newValue);
+
+				this._setDataVal(newValue);
+				this.setValue(newValue);
+
+				this._pauseEvent(ev);
+
+				return true;
+			},
+			_triggerFocusOnHandle: function(handleIdx) {
+				if(handleIdx === 0) {
+					this.handle1.focus();
+				}
+				if(handleIdx === 1) {
+					this.handle2.focus();
+				}
+			},
+			_keydown: function(handleIdx, ev) {
+				if(!this.options.enabled) {
+					return false;
+				}
+
+				var dir;
+				switch (ev.keyCode) {
+					case 37: // left
+					case 40: // down
+						dir = -1;
+						break;
+					case 39: // right
+					case 38: // up
+						dir = 1;
+						break;
+				}
+				if (!dir) {
+					return;
+				}
+
+				// use natural arrow keys instead of from min to max
+				if (this.options.natural_arrow_keys) {
+					var ifVerticalAndNotReversed = (this.options.orientation === 'vertical' && !this.options.reversed);
+					var ifHorizontalAndReversed = (this.options.orientation === 'horizontal' && this.options.reversed);
+
+					if (ifVerticalAndNotReversed || ifHorizontalAndReversed) {
+						dir = dir * -1;
+					}
+				}
+
+				var oneStepValuePercentageChange = dir * this.percentage[2];
+				var percentage = this.percentage[handleIdx] + oneStepValuePercentageChange;
+
+				if (percentage > 100) {
+					percentage = 100;
+				} else if (percentage < 0) {
+					percentage = 0;
+				}
+
+				this.dragged = handleIdx;
+				this._adjustPercentageForRangeSliders(percentage);
+				this.percentage[this.dragged] = percentage;
+				this._layout();
+
+				var val = this._calculateValue();
+
+				this._trigger('slideStart', val);
+				this._setDataVal(val);
+				this.setValue(val, true);
+
+				this._trigger('slideStop', val);
+				this._setDataVal(val);
+
+				this._pauseEvent(ev);
+
+				return false;
+			},
+			_pauseEvent: function(ev) {
+				if(ev.stopPropagation) {
+					ev.stopPropagation();
+				}
+			    if(ev.preventDefault) {
+			    	ev.preventDefault();
+			    }
+			    ev.cancelBubble=true;
+			    ev.returnValue=false;
+			},
+			_mousemove: function(ev) {
+				if(!this.options.enabled) {
+					return false;
+				}
+
+				var percentage = this._getPercentage(ev);
+				this._adjustPercentageForRangeSliders(percentage);
+				this.percentage[this.dragged] = this.options.reversed ? 100 - percentage : percentage;
+				this._layout();
+
+				var val = this._calculateValue();
+				this.setValue(val, true);
+
+				return false;
+			},
+			_adjustPercentageForRangeSliders: function(percentage) {
+				if (this.options.range) {
+					if (this.dragged === 0 && this.percentage[1] < percentage) {
+						this.percentage[0] = this.percentage[1];
+						this.dragged = 1;
+					} else if (this.dragged === 1 && this.percentage[0] > percentage) {
+						this.percentage[1] = this.percentage[0];
+						this.dragged = 0;
+					}
+				}
+			},
+			_mouseup: function() {
+				if(!this.options.enabled) {
+					return false;
+				}
+				if (this.touchCapable) {
+					// Touch: Unbind touch event handlers:
+					document.removeEventListener("touchmove", this.mousemove, false);
+					document.removeEventListener("touchend", this.mouseup, false);
+				}
+                // Unbind mouse event handlers:
+                document.removeEventListener("mousemove", this.mousemove, false);
+                document.removeEventListener("mouseup", this.mouseup, false);
+
+				this.inDrag = false;
+				if (this.over === false) {
+					this._hideTooltip();
+				}
+				var val = this._calculateValue();
+
+				this._layout();
+				this._trigger('slideStop', val);
+				this._setDataVal(val);
+
+				return false;
+			},
+			_calculateValue: function() {
+				var val;
+				if (this.options.range) {
+					val = [this.options.min,this.options.max];
+			        if (this.percentage[0] !== 0){
+			            val[0] = (Math.max(this.options.min, this.options.min + Math.round((this.diff * this.percentage[0]/100)/this.options.step)*this.options.step));
+			            val[0] = this._applyPrecision(val[0]);
+			        }
+			        if (this.percentage[1] !== 100){
+			            val[1] = (Math.min(this.options.max, this.options.min + Math.round((this.diff * this.percentage[1]/100)/this.options.step)*this.options.step));
+			            val[1] = this._applyPrecision(val[1]);
+			        }
+				} else {
+					val = (this.options.min + Math.round((this.diff * this.percentage[0]/100)/this.options.step)*this.options.step);
+					if (val < this.options.min) {
+						val = this.options.min;
+					}
+					else if (val > this.options.max) {
+						val = this.options.max;
+					}
+					val = parseFloat(val);
+					val = this._applyPrecision(val);
+				}
+				return val;
+			},
+			_applyPrecision: function(val) {
+				var precision = this.options.precision || this._getNumDigitsAfterDecimalPlace(this.options.step);
+				return this._applyToFixedAndParseFloat(val, precision);
+			},
+			_getNumDigitsAfterDecimalPlace: function(num) {
+				var match = (''+num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+				if (!match) { return 0; }
+				return Math.max(0, (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0));
+			},
+			_applyToFixedAndParseFloat: function(num, toFixedInput) {
+				var truncatedNum = num.toFixed(toFixedInput);
+				return parseFloat(truncatedNum);
+			},
+			/*
+				Credits to Mike Samuel for the following method!
+				Source: http://stackoverflow.com/questions/10454518/javascript-how-to-retrieve-the-number-of-decimals-of-a-string-number
+			*/
+			_getPercentage: function(ev) {
+				if (this.touchCapable && (ev.type === 'touchstart' || ev.type === 'touchmove')) {
+					ev = ev.touches[0];
+				}
+				var percentage = (ev[this.mousePos] - this.offset[this.stylePos])*100/this.size;
+				percentage = Math.round(percentage/this.percentage[2])*this.percentage[2];
+				return Math.max(0, Math.min(100, percentage));
+			},
+			_validateInputValue: function(val) {
+				if(typeof val === 'number') {
+					return val;
+				} else if(val instanceof Array) {
+					this._validateArray(val);
+					return val;
+				} else {
+					throw new Error( ErrorMsgs.formatInvalidInputErrorMsg(val) );
+				}
+			},
+			_validateArray: function(val) {
+				for(var i = 0; i < val.length; i++) {
+					var input =  val[i];
+					if (typeof input !== 'number') { throw new Error( ErrorMsgs.formatInvalidInputErrorMsg(input) ); }
+				}
+			},
+			_setDataVal: function(val) {
+				var value = "value: '" + val + "'";
+				this.element.setAttribute('data', value);
+				this.element.setAttribute('value', val);
+			},
+			_trigger: function(evt, val) {
+				val = (val || val === 0) ? val : undefined;
+
+				var callbackFnArray = this.eventToCallbackMap[evt];
+				if(callbackFnArray && callbackFnArray.length) {
+					for(var i = 0; i < callbackFnArray.length; i++) {
+						var callbackFn = callbackFnArray[i];
+						callbackFn(val);
+					}
+				}
+
+				/* If JQuery exists, trigger JQuery events */
+				if($) {
+					this._triggerJQueryEvent(evt, val);
+				}
+			},
+			_triggerJQueryEvent: function(evt, val) {
+				var eventData = {
+					type: evt,
+					value: val
+				};
+				this.$element.trigger(eventData);
+				this.$sliderElem.trigger(eventData);
+			},
+			_unbindJQueryEventHandlers: function() {
+				this.$element.off();
+				this.$sliderElem.off();
+			},
+			_setText: function(element, text) {
+				if(typeof element.innerText !== "undefined") {
+			 		element.innerText = text;
+			 	} else if(typeof element.textContent !== "undefined") {
+			 		element.textContent = text;
+			 	}
+			},
+			_removeClass: function(element, classString) {
+				var classes = classString.split(" ");
+				var newClasses = element.className;
+
+				for(var i = 0; i < classes.length; i++) {
+					var classTag = classes[i];
+					var regex = new RegExp("(?:\\s|^)" + classTag + "(?:\\s|$)");
+					newClasses = newClasses.replace(regex, " ");
+				}
+
+				element.className = newClasses.trim();
+			},
+			_addClass: function(element, classString) {
+				var classes = classString.split(" ");
+				var newClasses = element.className;
+
+				for(var i = 0; i < classes.length; i++) {
+					var classTag = classes[i];
+					var regex = new RegExp("(?:\\s|^)" + classTag + "(?:\\s|$)");
+					var ifClassExists = regex.test(newClasses);
+
+					if(!ifClassExists) {
+						newClasses += " " + classTag;
+					}
+				}
+
+				element.className = newClasses.trim();
+			},
+			_offset: function (obj) {
+				var ol = 0;
+				var ot = 0;
+				if (obj.offsetParent) {
+					do {
+					  ol += obj.offsetLeft;
+					  ot += obj.offsetTop;
+					} while (obj = obj.offsetParent);
+				}
+				return {
+					left: ol,
+					top: ot
+				};
+			},
+			_css: function(elementRef, styleName, value) {
+                if ($) {
+                    $.style(elementRef, styleName, value);
+                } else {
+                    var style = styleName.replace(/^-ms-/, "ms-").replace(/-([\da-z])/gi, function (all, letter) {
+                        return letter.toUpperCase();
+                    });
+                    elementRef.style[style] = value;
+                }
+			}
+		};
+
+		/*********************************
+
+			Attach to global namespace
+
+		*********************************/
+		if($) {
+			var namespace = $.fn.slider ? 'bootstrapSlider' : 'slider';
+			$.bridget(namespace, Slider);
+		}
+
+	})( $ );
+
+	return Slider;
+}));
\ No newline at end of file
diff --git a/dependencies/flatUI/css/flat-ui.css b/dependencies/flatUI/css/flat-ui.css
index 98b4eb1638f22b923067c12d123e4daec9872aa7..2452fab36974cfe53de7e8d5557e5e003d17fa7b 100755
--- a/dependencies/flatUI/css/flat-ui.css
+++ b/dependencies/flatUI/css/flat-ui.css
@@ -2423,87 +2423,87 @@ fieldset[disabled] .input-group-btn .btn-default.active {
 .progress-bar-info {
   background-color: #3498db;
   }
-.ui-slider {
-  position: relative;
-  height: 12px;
-  margin-bottom: 20px;
-  cursor: pointer;
-  background: #ebedef;
-  border-radius: 32px;
-  box-shadow: none;
-  }
-.ui-slider-handle {
-  position: absolute;
-  z-index: 2;
-  width: 18px;
-  height: 18px;
-  cursor: pointer;
-  background-color: #16a085;
-  border-radius: 50%;
-  -webkit-transition: background .25s;
-          transition: background .25s;
-  }
-.ui-slider-handle:hover,
-.ui-slider-handle:focus {
-  background-color: #48c9b0;
-  outline: none;
-  }
-.ui-slider-handle:active {
-  background-color: #16a085;
-  }
-.ui-slider-range {
-  position: absolute;
-  z-index: 1;
-  display: block;
-  height: 100%;
-  background-color: #1abc9c;
-  }
-.ui-slider-segment {
-  width: 6px;
-  height: 6px;
-  background-color: #d9dbdd;
-  border-radius: 50%;
-  }
-.ui-slider-value {
-  float: right;
-  margin-top: 12px;
-  font-size: 13px;
-  }
-.ui-slider-value.first {
-  float: left;
-  clear: left;
-  }
-.ui-slider-horizontal .ui-slider-handle {
-  top: -3px;
-  margin-left: -9px;
-  }
-.ui-slider-horizontal .ui-slider-handle[style*="100"] {
-  margin-left: -15px;
-  }
-.ui-slider-horizontal .ui-slider-range {
-  border-radius: 30px 0 0 30px;
-  }
-.ui-slider-horizontal .ui-slider-segment {
-  float: left;
-  margin: 3px -6px 0 0;
-  }
-.ui-slider-vertical {
-  width: 12px;
-  }
-.ui-slider-vertical .ui-slider-handle {
-  top: auto;
-  margin-bottom: -11px;
-  margin-left: -3px;
-  }
-.ui-slider-vertical .ui-slider-range {
-  bottom: 0;
-  width: 100%;
-  border-radius: 0 0 30px 30px;
-  }
-.ui-slider-vertical .ui-slider-segment {
-  position: absolute;
-  right: 3px;
-  }
+/*.ui-slider {*/
+  /*position: relative;*/
+  /*height: 12px;*/
+  /*margin-bottom: 20px;*/
+  /*cursor: pointer;*/
+  /*background: #ebedef;*/
+  /*border-radius: 32px;*/
+  /*box-shadow: none;*/
+  /*}*/
+/*.ui-slider-handle {*/
+  /*position: absolute;*/
+  /*z-index: 2;*/
+  /*width: 18px;*/
+  /*height: 18px;*/
+  /*cursor: pointer;*/
+  /*background-color: #16a085;*/
+  /*border-radius: 50%;*/
+  /*-webkit-transition: background .25s;*/
+          /*transition: background .25s;*/
+  /*}*/
+/*.ui-slider-handle:hover,*/
+/*.ui-slider-handle:focus {*/
+  /*background-color: #48c9b0;*/
+  /*outline: none;*/
+  /*}*/
+/*.ui-slider-handle:active {*/
+  /*background-color: #16a085;*/
+  /*}*/
+/*.ui-slider-range {*/
+  /*position: absolute;*/
+  /*z-index: 1;*/
+  /*display: block;*/
+  /*height: 100%;*/
+  /*background-color: #1abc9c;*/
+  /*}*/
+/*.ui-slider-segment {*/
+  /*width: 6px;*/
+  /*height: 6px;*/
+  /*background-color: #d9dbdd;*/
+  /*border-radius: 50%;*/
+  /*}*/
+/*.ui-slider-value {*/
+  /*float: right;*/
+  /*margin-top: 12px;*/
+  /*font-size: 13px;*/
+  /*}*/
+/*.ui-slider-value.first {*/
+  /*float: left;*/
+  /*clear: left;*/
+  /*}*/
+/*.ui-slider-horizontal .ui-slider-handle {*/
+  /*top: -3px;*/
+  /*margin-left: -9px;*/
+  /*}*/
+/*.ui-slider-horizontal .ui-slider-handle[style*="100"] {*/
+  /*margin-left: -15px;*/
+  /*}*/
+/*.ui-slider-horizontal .ui-slider-range {*/
+  /*border-radius: 30px 0 0 30px;*/
+  /*}*/
+/*.ui-slider-horizontal .ui-slider-segment {*/
+  /*float: left;*/
+  /*margin: 3px -6px 0 0;*/
+  /*}*/
+/*.ui-slider-vertical {*/
+  /*width: 12px;*/
+  /*}*/
+/*.ui-slider-vertical .ui-slider-handle {*/
+  /*top: auto;*/
+  /*margin-bottom: -11px;*/
+  /*margin-left: -3px;*/
+  /*}*/
+/*.ui-slider-vertical .ui-slider-range {*/
+  /*bottom: 0;*/
+  /*width: 100%;*/
+  /*border-radius: 0 0 30px 30px;*/
+  /*}*/
+/*.ui-slider-vertical .ui-slider-segment {*/
+  /*position: absolute;*/
+  /*right: 3px;*/
+  /*}*/
 .pager {
   display: inline-block;
   font-size: 16px;
@@ -3097,59 +3097,59 @@ fieldset[disabled] .input-group-btn .btn-default.active {
 .pagination-dropdown.dropup {
   position: relative;
   }
-.tooltip {
-  z-index: 1070;
-  font-size: 14px;
-  line-height: 1.286;
-  }
-.tooltip.in {
-  filter: alpha(opacity=100);
-  opacity: 1;
-  }
-.tooltip.top {
-  padding: 9px 0;
-  margin-top: -5px;
-  }
-.tooltip.right {
-  padding: 0 9px;
-  margin-left: 5px;
-  }
-.tooltip.bottom {
-  padding: 9px 0;
-  margin-top: 5px;
-  }
-.tooltip.left {
-  padding: 0 9px;
-  margin-left: -5px;
-  }
-.tooltip-inner {
-  max-width: 183px;
-  padding: 12px 12px;
-  line-height: 1.286;
-  color: #fff;
-  background-color: #34495e;
-  border-radius: 6px;
-  }
-.tooltip.top .tooltip-arrow {
-  margin-left: -9px;
-  border-width: 9px 9px 0;
-  border-top-color: #34495e;
-  }
-.tooltip.right .tooltip-arrow {
-  margin-top: -9px;
-  border-width: 9px 9px 9px 0;
-  border-right-color: #34495e;
-  }
-.tooltip.left .tooltip-arrow {
-  margin-top: -9px;
-  border-width: 9px 0 9px 9px;
-  border-left-color: #34495e;
-  }
-.tooltip.bottom .tooltip-arrow {
-  margin-left: -9px;
-  border-width: 0 9px 9px;
-  border-bottom-color: #34495e;
-  }
+/*.tooltip {*/
+  /*z-index: 1070;*/
+  /*font-size: 14px;*/
+  /*line-height: 1.286;*/
+  /*}*/
+/*.tooltip.in {*/
+  /*filter: alpha(opacity=100);*/
+  /*opacity: 1;*/
+  /*}*/
+/*.tooltip.top {*/
+  /*padding: 9px 0;*/
+  /*margin-top: -5px;*/
+  /*}*/
+/*.tooltip.right {*/
+  /*padding: 0 9px;*/
+  /*margin-left: 5px;*/
+  /*}*/
+/*.tooltip.bottom {*/
+  /*padding: 9px 0;*/
+  /*margin-top: 5px;*/
+  /*}*/
+/*.tooltip.left {*/
+  /*padding: 0 9px;*/
+  /*margin-left: -5px;*/
+  /*}*/
+/*.tooltip-inner {*/
+  /*max-width: 183px;*/
+  /*padding: 12px 12px;*/
+  /*line-height: 1.286;*/
+  /*color: #fff;*/
+  /*background-color: #34495e;*/
+  /*border-radius: 6px;*/
+  /*}*/
+/*.tooltip.top .tooltip-arrow {*/
+  /*margin-left: -9px;*/
+  /*border-width: 9px 9px 0;*/
+  /*border-top-color: #34495e;*/
+  /*}*/
+/*.tooltip.right .tooltip-arrow {*/
+  /*margin-top: -9px;*/
+  /*border-width: 9px 9px 9px 0;*/
+  /*border-right-color: #34495e;*/
+  /*}*/
+/*.tooltip.left .tooltip-arrow {*/
+  /*margin-top: -9px;*/
+  /*border-width: 9px 0 9px 9px;*/
+  /*border-left-color: #34495e;*/
+  /*}*/
+/*.tooltip.bottom .tooltip-arrow {*/
+  /*margin-left: -9px;*/
+  /*border-width: 0 9px 9px;*/
+  /*border-bottom-color: #34495e;*/
+  /*}*/
 .caret {
   display: inline-block;
   width: 0;
@@ -6184,17 +6184,17 @@ footer p {
     height: 33px;
     border: 2px solid #bdc3c7;
     }
-  .tooltip {
-    border: 2px solid #bdc3c7;
-    }
-  .progress,
-  .ui-slider {
-    background: #ddd !important;
-    }
-  .progress-bar,
-  .ui-slider-range,
-  .ui-slider-handle {
-    background: #bdc3c7 !important;
-    }
+  /*.tooltip {*/
+    /*border: 2px solid #bdc3c7;*/
+    /*}*/
+  /*.progress,*/
+  /*.ui-slider {*/
+    /*background: #ddd !important;*/
+    /*}*/
+  /*.progress-bar,*/
+  /*.ui-slider-range,*/
+  /*.ui-slider-handle {*/
+    /*background: #bdc3c7 !important;*/
+    /*}*/
   }
 /*# sourceMappingURL=flat-ui.css.map */
diff --git a/dependencies/flatUI/js/flat-ui.js b/dependencies/flatUI/js/flat-ui.js
index 1dee0c414de98fc7382d09c1fc59d1479af87b6c..cdbc16791f6b37261358d5c7a7110ba13554610e 100755
--- a/dependencies/flatUI/js/flat-ui.js
+++ b/dependencies/flatUI/js/flat-ui.js
@@ -1928,667 +1928,667 @@ $.widget( "ui.buttonset", {
  *	jquery.ui.mouse.js
  *	jquery.ui.widget.js
  */
-(function( $, undefined ) {
-
-// 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, {
-	version: "1.10.4",
-	widgetEventPrefix: "slide",
-
-	options: {
-		animate: false,
-		distance: 0,
-		max: 100,
-		min: 0,
-		orientation: "horizontal",
-		range: false,
-		step: 1,
-		value: 0,
-		values: null,
-
-		// callbacks
-		change: null,
-		slide: null,
-		start: null,
-		stop: null
-	},
-
-	_create: function() {
-		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");
-
-		this._refresh();
-		this._setOption( "disabled", this.options.disabled );
-
-		this._animateOff = false;
-	},
-
-	_refresh: function() {
-		this._createRange();
-		this._createHandles();
-		this._setupEvents();
-		this._refreshValue();
-	},
-
-	_createHandles: function() {
-		var i, handleCount,
-			options = this.options,
-			existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
-			handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
-			handles = [];
-
-		handleCount = ( options.values && options.values.length ) || 1;
-
-		if ( existingHandles.length > handleCount ) {
-			existingHandles.slice( handleCount ).remove();
-			existingHandles = existingHandles.slice( 0, handleCount );
-		}
-
-		for ( i = existingHandles.length; i < handleCount; i++ ) {
-			handles.push( handle );
-		}
-
-		this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
-
-		this.handle = this.handles.eq( 0 );
-
-		this.handles.each(function( i ) {
-			$( this ).data( "ui-slider-handle-index", i );
-		});
-	},
-
-	_createRange: function() {
-		var options = this.options,
-			classes = "";
-
-		if ( options.range ) {
-			if ( options.range === true ) {
-				if ( !options.values ) {
-					options.values = [ this._valueMin(), this._valueMin() ];
-				} else if ( options.values.length && options.values.length !== 2 ) {
-					options.values = [ options.values[0], options.values[0] ];
-				} else if ( $.isArray( options.values ) ) {
-					options.values = options.values.slice(0);
-				}
-			}
-
-			if ( !this.range || !this.range.length ) {
-				this.range = $( "<div></div>" )
-					.appendTo( this.element );
-
-				classes = "ui-slider-range" +
-				// note: this isn't the most fittingly semantic framework class for this element,
-				// but worked best visually with a variety of themes
-				" ui-widget-header ui-corner-all";
-			} else {
-				this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
-					// Handle range switching from true to min/max
-					.css({
-						"left": "",
-						"bottom": ""
-					});
-			}
-
-			this.range.addClass( classes +
-				( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
-		} else {
-			if ( this.range ) {
-				this.range.remove();
-			}
-			this.range = null;
-		}
-	},
-
-	_setupEvents: function() {
-		var elements = this.handles.add( this.range ).filter( "a" );
-		this._off( elements );
-		this._on( elements, this._handleEvents );
-		this._hoverable( elements );
-		this._focusable( elements );
-	},
-
-	_destroy: function() {
-		this.handles.remove();
-		if ( this.range ) {
-			this.range.remove();
-		}
-
-		this.element
-			.removeClass( "ui-slider" +
-				" ui-slider-horizontal" +
-				" ui-slider-vertical" +
-				" ui-widget" +
-				" ui-widget-content" +
-				" ui-corner-all" );
-
-		this._mouseDestroy();
-	},
-
-	_mouseCapture: function( event ) {
-		var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
-			that = this,
-			o = this.options;
-
-		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;
-		this.handles.each(function( i ) {
-			var thisDistance = Math.abs( normValue - that.values(i) );
-			if (( distance > thisDistance ) ||
-				( distance === thisDistance &&
-					(i === that._lastChangedValue || that.values(i) === o.min ))) {
-				distance = thisDistance;
-				closestHandle = $( this );
-				index = i;
-			}
-		});
-
-		allowed = this._start( event, index );
-		if ( allowed === false ) {
-			return false;
-		}
-		this._mouseSliding = true;
-
-		this._handleIndex = index;
-
-		closestHandle
-			.addClass( "ui-state-active" )
-			.focus();
-
-		offset = closestHandle.offset();
-		mouseOverHandle = !$( event.target ).parents().addBack().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)
-		};
-
-		if ( !this.handles.hasClass( "ui-state-hover" ) ) {
-			this._slide( event, index, normValue );
-		}
-		this._animateOff = true;
-		return true;
-	},
-
-	_mouseStart: function() {
-		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 );
-				}
-			}
-		} 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();
-			}
-
-			//store the last changed value index for reference when handles overlap
-			this._lastChangedValue = index;
-
-			this._trigger( "change", event, uiHash );
-		}
-	},
-
-	value: function( newValue ) {
-		if ( arguments.length ) {
-			this.options.value = this._trimAlignValue( newValue );
-			this._refreshValue();
-			this._change( null, 0 );
-			return;
-		}
-
-		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 );
-			return;
-		}
-
-		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 ( key === "range" && this.options.range === true ) {
-			if ( value === "min" ) {
-				this.options.value = this._values( 0 );
-				this.options.values = null;
-			} else if ( value === "max" ) {
-				this.options.value = this._values( this.options.values.length-1 );
-				this.options.values = null;
-			}
-		}
-
-		if ( $.isArray( this.options.values ) ) {
-			valsLength = this.options.values.length;
-		}
-
-		$.Widget.prototype._setOption.apply( this, arguments );
-
-		switch ( key ) {
-			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;
-			case "min":
-			case "max":
-				this._animateOff = true;
-				this._refreshValue();
-				this._animateOff = false;
-				break;
-			case "range":
-				this._animateOff = true;
-				this._refresh();
-				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 if ( this.options.values && this.options.values.length ) {
-			// .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;
-		} else {
-			return [];
-		}
-	},
-
-	// 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 > 0 ) ? this.options.step : 1,
-			valModStep = (val - this._valueMin()) % step,
-			alignValue = val - valModStep;
-
-		if ( Math.abs(valModStep) * 2 >= step ) {
-			alignValue += ( valModStep > 0 ) ? step : ( -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 lastValPercent, valPercent, value, valueMin, valueMax,
-			oRange = this.options.range,
-			o = this.options,
-			that = this,
-			animate = ( !this._animateOff ) ? o.animate : false,
-			_set = {};
-
-		if ( this.options.values && this.options.values.length ) {
-			this.handles.each(function( i ) {
-				valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
-				_set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
-				$( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
-				if ( that.options.range === true ) {
-					if ( that.orientation === "horizontal" ) {
-						if ( i === 0 ) {
-							that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
-						}
-						if ( i === 1 ) {
-							that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
-						}
-					} else {
-						if ( i === 0 ) {
-							that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
-						}
-						if ( i === 1 ) {
-							that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
-						}
-					}
-				}
-				lastValPercent = valPercent;
-			});
-		} else {
-			value = this.value();
-			valueMin = this._valueMin();
-			valueMax = this._valueMax();
-			valPercent = ( valueMax !== valueMin ) ?
-					( value - valueMin ) / ( valueMax - valueMin ) * 100 :
-					0;
-			_set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
-			this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
-
-			if ( oRange === "min" && this.orientation === "horizontal" ) {
-				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
-			}
-			if ( oRange === "max" && this.orientation === "horizontal" ) {
-				this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
-			}
-			if ( oRange === "min" && this.orientation === "vertical" ) {
-				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
-			}
-			if ( oRange === "max" && this.orientation === "vertical" ) {
-				this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
-			}
-		}
-	},
-
-	_handleEvents: {
-		keydown: function( event ) {
-			var allowed, curVal, newVal, step,
-				index = $( event.target ).data( "ui-slider-handle-index" );
-
-			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:
-					event.preventDefault();
-					if ( !this._keySliding ) {
-						this._keySliding = true;
-						$( event.target ).addClass( "ui-state-active" );
-						allowed = this._start( event, index );
-						if ( allowed === false ) {
-							return;
-						}
-					}
-					break;
-			}
-
-			step = this.options.step;
-			if ( this.options.values && this.options.values.length ) {
-				curVal = newVal = this.values( index );
-			} else {
-				curVal = newVal = this.value();
-			}
-
-			switch ( event.keyCode ) {
-				case $.ui.keyCode.HOME:
-					newVal = this._valueMin();
-					break;
-				case $.ui.keyCode.END:
-					newVal = this._valueMax();
-					break;
-				case $.ui.keyCode.PAGE_UP:
-					newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
-					break;
-				case $.ui.keyCode.PAGE_DOWN:
-					newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
-					break;
-				case $.ui.keyCode.UP:
-				case $.ui.keyCode.RIGHT:
-					if ( curVal === this._valueMax() ) {
-						return;
-					}
-					newVal = this._trimAlignValue( curVal + step );
-					break;
-				case $.ui.keyCode.DOWN:
-				case $.ui.keyCode.LEFT:
-					if ( curVal === this._valueMin() ) {
-						return;
-					}
-					newVal = this._trimAlignValue( curVal - step );
-					break;
-			}
-
-			this._slide( event, index, newVal );
-		},
-		click: function( event ) {
-			event.preventDefault();
-		},
-		keyup: function( event ) {
-			var index = $( event.target ).data( "ui-slider-handle-index" );
-
-			if ( this._keySliding ) {
-				this._keySliding = false;
-				this._stop( event, index );
-				this._change( event, index );
-				$( event.target ).removeClass( "ui-state-active" );
-			}
-		}
-	}
-
-});
-
-}(jQuery));
+//(function( $, undefined ) {
+//
+//// 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, {
+//	version: "1.10.4",
+//	widgetEventPrefix: "slide",
+//
+//	options: {
+//		animate: false,
+//		distance: 0,
+//		max: 100,
+//		min: 0,
+//		orientation: "horizontal",
+//		range: false,
+//		step: 1,
+//		value: 0,
+//		values: null,
+//
+//		// callbacks
+//		change: null,
+//		slide: null,
+//		start: null,
+//		stop: null
+//	},
+//
+//	_create: function() {
+//		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");
+//
+//		this._refresh();
+//		this._setOption( "disabled", this.options.disabled );
+//
+//		this._animateOff = false;
+//	},
+//
+//	_refresh: function() {
+//		this._createRange();
+//		this._createHandles();
+//		this._setupEvents();
+//		this._refreshValue();
+//	},
+//
+//	_createHandles: function() {
+//		var i, handleCount,
+//			options = this.options,
+//			existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
+//			handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
+//			handles = [];
+//
+//		handleCount = ( options.values && options.values.length ) || 1;
+//
+//		if ( existingHandles.length > handleCount ) {
+//			existingHandles.slice( handleCount ).remove();
+//			existingHandles = existingHandles.slice( 0, handleCount );
+//		}
+//
+//		for ( i = existingHandles.length; i < handleCount; i++ ) {
+//			handles.push( handle );
+//		}
+//
+//		this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
+//
+//		this.handle = this.handles.eq( 0 );
+//
+//		this.handles.each(function( i ) {
+//			$( this ).data( "ui-slider-handle-index", i );
+//		});
+//	},
+//
+//	_createRange: function() {
+//		var options = this.options,
+//			classes = "";
+//
+//		if ( options.range ) {
+//			if ( options.range === true ) {
+//				if ( !options.values ) {
+//					options.values = [ this._valueMin(), this._valueMin() ];
+//				} else if ( options.values.length && options.values.length !== 2 ) {
+//					options.values = [ options.values[0], options.values[0] ];
+//				} else if ( $.isArray( options.values ) ) {
+//					options.values = options.values.slice(0);
+//				}
+//			}
+//
+//			if ( !this.range || !this.range.length ) {
+//				this.range = $( "<div></div>" )
+//					.appendTo( this.element );
+//
+//				classes = "ui-slider-range" +
+//				// note: this isn't the most fittingly semantic framework class for this element,
+//				// but worked best visually with a variety of themes
+//				" ui-widget-header ui-corner-all";
+//			} else {
+//				this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
+//					// Handle range switching from true to min/max
+//					.css({
+//						"left": "",
+//						"bottom": ""
+//					});
+//			}
+//
+//			this.range.addClass( classes +
+//				( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
+//		} else {
+//			if ( this.range ) {
+//				this.range.remove();
+//			}
+//			this.range = null;
+//		}
+//	},
+//
+//	_setupEvents: function() {
+//		var elements = this.handles.add( this.range ).filter( "a" );
+//		this._off( elements );
+//		this._on( elements, this._handleEvents );
+//		this._hoverable( elements );
+//		this._focusable( elements );
+//	},
+//
+//	_destroy: function() {
+//		this.handles.remove();
+//		if ( this.range ) {
+//			this.range.remove();
+//		}
+//
+//		this.element
+//			.removeClass( "ui-slider" +
+//				" ui-slider-horizontal" +
+//				" ui-slider-vertical" +
+//				" ui-widget" +
+//				" ui-widget-content" +
+//				" ui-corner-all" );
+//
+//		this._mouseDestroy();
+//	},
+//
+//	_mouseCapture: function( event ) {
+//		var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
+//			that = this,
+//			o = this.options;
+//
+//		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;
+//		this.handles.each(function( i ) {
+//			var thisDistance = Math.abs( normValue - that.values(i) );
+//			if (( distance > thisDistance ) ||
+//				( distance === thisDistance &&
+//					(i === that._lastChangedValue || that.values(i) === o.min ))) {
+//				distance = thisDistance;
+//				closestHandle = $( this );
+//				index = i;
+//			}
+//		});
+//
+//		allowed = this._start( event, index );
+//		if ( allowed === false ) {
+//			return false;
+//		}
+//		this._mouseSliding = true;
+//
+//		this._handleIndex = index;
+//
+//		closestHandle
+//			.addClass( "ui-state-active" )
+//			.focus();
+//
+//		offset = closestHandle.offset();
+//		mouseOverHandle = !$( event.target ).parents().addBack().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)
+//		};
+//
+//		if ( !this.handles.hasClass( "ui-state-hover" ) ) {
+//			this._slide( event, index, normValue );
+//		}
+//		this._animateOff = true;
+//		return true;
+//	},
+//
+//	_mouseStart: function() {
+//		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 );
+//				}
+//			}
+//		} 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();
+//			}
+//
+//			//store the last changed value index for reference when handles overlap
+//			this._lastChangedValue = index;
+//
+//			this._trigger( "change", event, uiHash );
+//		}
+//	},
+//
+//	value: function( newValue ) {
+//		if ( arguments.length ) {
+//			this.options.value = this._trimAlignValue( newValue );
+//			this._refreshValue();
+//			this._change( null, 0 );
+//			return;
+//		}
+//
+//		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 );
+//			return;
+//		}
+//
+//		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 ( key === "range" && this.options.range === true ) {
+//			if ( value === "min" ) {
+//				this.options.value = this._values( 0 );
+//				this.options.values = null;
+//			} else if ( value === "max" ) {
+//				this.options.value = this._values( this.options.values.length-1 );
+//				this.options.values = null;
+//			}
+//		}
+//
+//		if ( $.isArray( this.options.values ) ) {
+//			valsLength = this.options.values.length;
+//		}
+//
+//		$.Widget.prototype._setOption.apply( this, arguments );
+//
+//		switch ( key ) {
+//			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;
+//			case "min":
+//			case "max":
+//				this._animateOff = true;
+//				this._refreshValue();
+//				this._animateOff = false;
+//				break;
+//			case "range":
+//				this._animateOff = true;
+//				this._refresh();
+//				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 if ( this.options.values && this.options.values.length ) {
+//			// .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;
+//		} else {
+//			return [];
+//		}
+//	},
+//
+//	// 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 > 0 ) ? this.options.step : 1,
+//			valModStep = (val - this._valueMin()) % step,
+//			alignValue = val - valModStep;
+//
+//		if ( Math.abs(valModStep) * 2 >= step ) {
+//			alignValue += ( valModStep > 0 ) ? step : ( -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 lastValPercent, valPercent, value, valueMin, valueMax,
+//			oRange = this.options.range,
+//			o = this.options,
+//			that = this,
+//			animate = ( !this._animateOff ) ? o.animate : false,
+//			_set = {};
+//
+//		if ( this.options.values && this.options.values.length ) {
+//			this.handles.each(function( i ) {
+//				valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
+//				_set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
+//				$( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
+//				if ( that.options.range === true ) {
+//					if ( that.orientation === "horizontal" ) {
+//						if ( i === 0 ) {
+//							that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
+//						}
+//						if ( i === 1 ) {
+//							that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
+//						}
+//					} else {
+//						if ( i === 0 ) {
+//							that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
+//						}
+//						if ( i === 1 ) {
+//							that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
+//						}
+//					}
+//				}
+//				lastValPercent = valPercent;
+//			});
+//		} else {
+//			value = this.value();
+//			valueMin = this._valueMin();
+//			valueMax = this._valueMax();
+//			valPercent = ( valueMax !== valueMin ) ?
+//					( value - valueMin ) / ( valueMax - valueMin ) * 100 :
+//					0;
+//			_set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
+//			this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
+//
+//			if ( oRange === "min" && this.orientation === "horizontal" ) {
+//				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
+//			}
+//			if ( oRange === "max" && this.orientation === "horizontal" ) {
+//				this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
+//			}
+//			if ( oRange === "min" && this.orientation === "vertical" ) {
+//				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
+//			}
+//			if ( oRange === "max" && this.orientation === "vertical" ) {
+//				this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
+//			}
+//		}
+//	},
+//
+//	_handleEvents: {
+//		keydown: function( event ) {
+//			var allowed, curVal, newVal, step,
+//				index = $( event.target ).data( "ui-slider-handle-index" );
+//
+//			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:
+//					event.preventDefault();
+//					if ( !this._keySliding ) {
+//						this._keySliding = true;
+//						$( event.target ).addClass( "ui-state-active" );
+//						allowed = this._start( event, index );
+//						if ( allowed === false ) {
+//							return;
+//						}
+//					}
+//					break;
+//			}
+//
+//			step = this.options.step;
+//			if ( this.options.values && this.options.values.length ) {
+//				curVal = newVal = this.values( index );
+//			} else {
+//				curVal = newVal = this.value();
+//			}
+//
+//			switch ( event.keyCode ) {
+//				case $.ui.keyCode.HOME:
+//					newVal = this._valueMin();
+//					break;
+//				case $.ui.keyCode.END:
+//					newVal = this._valueMax();
+//					break;
+//				case $.ui.keyCode.PAGE_UP:
+//					newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
+//					break;
+//				case $.ui.keyCode.PAGE_DOWN:
+//					newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
+//					break;
+//				case $.ui.keyCode.UP:
+//				case $.ui.keyCode.RIGHT:
+//					if ( curVal === this._valueMax() ) {
+//						return;
+//					}
+//					newVal = this._trimAlignValue( curVal + step );
+//					break;
+//				case $.ui.keyCode.DOWN:
+//				case $.ui.keyCode.LEFT:
+//					if ( curVal === this._valueMin() ) {
+//						return;
+//					}
+//					newVal = this._trimAlignValue( curVal - step );
+//					break;
+//			}
+//
+//			this._slide( event, index, newVal );
+//		},
+//		click: function( event ) {
+//			event.preventDefault();
+//		},
+//		keyup: function( event ) {
+//			var index = $( event.target ).data( "ui-slider-handle-index" );
+//
+//			if ( this._keySliding ) {
+//				this._keySliding = false;
+//				this._stop( event, index );
+//				this._change( event, index );
+//				$( event.target ).removeClass( "ui-state-active" );
+//			}
+//		}
+//	}
+//
+//});
+//
+//}(jQuery));
 
 /*!
  * jQuery UI Effects 1.10.4
@@ -3880,165 +3880,165 @@ $.each( baseEasings, function( name, easeIn ) {
 
 })(jQuery);
 
-/*!
- * jQuery UI Touch Punch 0.2.2
- *
- * Copyright 2011, Dave Furfero
- * Dual licensed under the MIT or GPL Version 2 licenses.
- *
- * Depends:
- *  jquery.ui.widget.js
- *  jquery.ui.mouse.js
- */
-(function ($) {
-
-  // Detect touch support
-  $.support.touch = 'ontouchend' in document;
-
-  // Ignore browsers without touch support
-  if (!$.support.touch) {
-    return;
-  }
-
-  var mouseProto = $.ui.mouse.prototype,
-      _mouseInit = mouseProto._mouseInit,
-      touchHandled;
-
-  /**
-   * Simulate a mouse event based on a corresponding touch event
-   * @param {Object} event A touch event
-   * @param {String} simulatedType The corresponding mouse event
-   */
-  function simulateMouseEvent (event, simulatedType) {
-
-    // Ignore multi-touch events
-    if (event.originalEvent.touches.length > 1) {
-      return;
-    }
-
-    event.preventDefault();
-
-    var touch = event.originalEvent.changedTouches[0],
-        simulatedEvent = document.createEvent('MouseEvents');
-    
-    // Initialize the simulated mouse event using the touch event's coordinates
-    simulatedEvent.initMouseEvent(
-      simulatedType,    // type
-      true,             // bubbles                    
-      true,             // cancelable                 
-      window,           // view                       
-      1,                // detail                     
-      touch.screenX,    // screenX                    
-      touch.screenY,    // screenY                    
-      touch.clientX,    // clientX                    
-      touch.clientY,    // clientY                    
-      false,            // ctrlKey                    
-      false,            // altKey                     
-      false,            // shiftKey                   
-      false,            // metaKey                    
-      0,                // button                     
-      null              // relatedTarget              
-    );
-
-    // Dispatch the simulated event to the target element
-    event.target.dispatchEvent(simulatedEvent);
-  }
-
-  /**
-   * Handle the jQuery UI widget's touchstart events
-   * @param {Object} event The widget element's touchstart event
-   */
-  mouseProto._touchStart = function (event) {
-
-    var self = this;
-
-    // Ignore the event if another widget is already being handled
-    if (touchHandled || !self._mouseCapture(event.originalEvent.changedTouches[0])) {
-      return;
-    }
-
-    // Set the flag to prevent other widgets from inheriting the touch event
-    touchHandled = true;
-
-    // Track movement to determine if interaction was a click
-    self._touchMoved = false;
-
-    // Simulate the mouseover event
-    simulateMouseEvent(event, 'mouseover');
-
-    // Simulate the mousemove event
-    simulateMouseEvent(event, 'mousemove');
-
-    // Simulate the mousedown event
-    simulateMouseEvent(event, 'mousedown');
-  };
-
-  /**
-   * Handle the jQuery UI widget's touchmove events
-   * @param {Object} event The document's touchmove event
-   */
-  mouseProto._touchMove = function (event) {
-
-    // Ignore event if not handled
-    if (!touchHandled) {
-      return;
-    }
-
-    // Interaction was not a click
-    this._touchMoved = true;
-
-    // Simulate the mousemove event
-    simulateMouseEvent(event, 'mousemove');
-  };
-
-  /**
-   * Handle the jQuery UI widget's touchend events
-   * @param {Object} event The document's touchend event
-   */
-  mouseProto._touchEnd = function (event) {
-
-    // Ignore event if not handled
-    if (!touchHandled) {
-      return;
-    }
-
-    // Simulate the mouseup event
-    simulateMouseEvent(event, 'mouseup');
-
-    // Simulate the mouseout event
-    simulateMouseEvent(event, 'mouseout');
-
-    // If the touch interaction did not move, it should trigger a click
-    if (!this._touchMoved) {
-
-      // Simulate the click event
-      simulateMouseEvent(event, 'click');
-    }
-
-    // Unset the flag to allow other widgets to inherit the touch event
-    touchHandled = false;
-  };
-
-  /**
-   * A duck punch of the $.ui.mouse _mouseInit method to support touch events.
-   * This method extends the widget with bound touch event handlers that
-   * translate touch events to mouse events and pass them to the widget's
-   * original mouse event handling methods.
-   */
-  mouseProto._mouseInit = function () {
-    
-    var self = this;
-
-    // Delegate the touch handlers to the widget's element
-    self.element
-      .bind('touchstart', $.proxy(self, '_touchStart'))
-      .bind('touchmove', $.proxy(self, '_touchMove'))
-      .bind('touchend', $.proxy(self, '_touchEnd'));
-
-    // Call the original $.ui.mouse init method
-    _mouseInit.call(self);
-  };
-
+/*!
+ * jQuery UI Touch Punch 0.2.2
+ *
+ * Copyright 2011, Dave Furfero
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ * Depends:
+ *  jquery.ui.widget.js
+ *  jquery.ui.mouse.js
+ */
+(function ($) {
+
+  // Detect touch support
+  $.support.touch = 'ontouchend' in document;
+
+  // Ignore browsers without touch support
+  if (!$.support.touch) {
+    return;
+  }
+
+  var mouseProto = $.ui.mouse.prototype,
+      _mouseInit = mouseProto._mouseInit,
+      touchHandled;
+
+  /**
+   * Simulate a mouse event based on a corresponding touch event
+   * @param {Object} event A touch event
+   * @param {String} simulatedType The corresponding mouse event
+   */
+  function simulateMouseEvent (event, simulatedType) {
+
+    // Ignore multi-touch events
+    if (event.originalEvent.touches.length > 1) {
+      return;
+    }
+
+    event.preventDefault();
+
+    var touch = event.originalEvent.changedTouches[0],
+        simulatedEvent = document.createEvent('MouseEvents');
+    
+    // Initialize the simulated mouse event using the touch event's coordinates
+    simulatedEvent.initMouseEvent(
+      simulatedType,    // type
+      true,             // bubbles                    
+      true,             // cancelable                 
+      window,           // view                       
+      1,                // detail                     
+      touch.screenX,    // screenX                    
+      touch.screenY,    // screenY                    
+      touch.clientX,    // clientX                    
+      touch.clientY,    // clientY                    
+      false,            // ctrlKey                    
+      false,            // altKey                     
+      false,            // shiftKey                   
+      false,            // metaKey                    
+      0,                // button                     
+      null              // relatedTarget              
+    );
+
+    // Dispatch the simulated event to the target element
+    event.target.dispatchEvent(simulatedEvent);
+  }
+
+  /**
+   * Handle the jQuery UI widget's touchstart events
+   * @param {Object} event The widget element's touchstart event
+   */
+  mouseProto._touchStart = function (event) {
+
+    var self = this;
+
+    // Ignore the event if another widget is already being handled
+    if (touchHandled || !self._mouseCapture(event.originalEvent.changedTouches[0])) {
+      return;
+    }
+
+    // Set the flag to prevent other widgets from inheriting the touch event
+    touchHandled = true;
+
+    // Track movement to determine if interaction was a click
+    self._touchMoved = false;
+
+    // Simulate the mouseover event
+    simulateMouseEvent(event, 'mouseover');
+
+    // Simulate the mousemove event
+    simulateMouseEvent(event, 'mousemove');
+
+    // Simulate the mousedown event
+    simulateMouseEvent(event, 'mousedown');
+  };
+
+  /**
+   * Handle the jQuery UI widget's touchmove events
+   * @param {Object} event The document's touchmove event
+   */
+  mouseProto._touchMove = function (event) {
+
+    // Ignore event if not handled
+    if (!touchHandled) {
+      return;
+    }
+
+    // Interaction was not a click
+    this._touchMoved = true;
+
+    // Simulate the mousemove event
+    simulateMouseEvent(event, 'mousemove');
+  };
+
+  /**
+   * Handle the jQuery UI widget's touchend events
+   * @param {Object} event The document's touchend event
+   */
+  mouseProto._touchEnd = function (event) {
+
+    // Ignore event if not handled
+    if (!touchHandled) {
+      return;
+    }
+
+    // Simulate the mouseup event
+    simulateMouseEvent(event, 'mouseup');
+
+    // Simulate the mouseout event
+    simulateMouseEvent(event, 'mouseout');
+
+    // If the touch interaction did not move, it should trigger a click
+    if (!this._touchMoved) {
+
+      // Simulate the click event
+      simulateMouseEvent(event, 'click');
+    }
+
+    // Unset the flag to allow other widgets to inherit the touch event
+    touchHandled = false;
+  };
+
+  /**
+   * A duck punch of the $.ui.mouse _mouseInit method to support touch events.
+   * This method extends the widget with bound touch event handlers that
+   * translate touch events to mouse events and pass them to the widget's
+   * original mouse event handling methods.
+   */
+  mouseProto._mouseInit = function () {
+    
+    var self = this;
+
+    // Delegate the touch handlers to the widget's element
+    self.element
+      .bind('touchstart', $.proxy(self, '_touchStart'))
+      .bind('touchmove', $.proxy(self, '_touchMove'))
+      .bind('touchend', $.proxy(self, '_touchEnd'));
+
+    // Call the original $.ui.mouse init method
+    _mouseInit.call(self);
+  };
+
 })(jQuery);
 /*!
  * Bootstrap v3.2.0 (http://getbootstrap.com)
@@ -5150,453 +5150,453 @@ if (typeof jQuery === 'undefined') { throw new Error('Bootstrap\'s JavaScript re
  * ======================================================================== */
 
 
-+function ($) {
-  'use strict';
-
-  // TOOLTIP PUBLIC CLASS DEFINITION
-  // ===============================
-
-  var Tooltip = function (element, options) {
-    this.type       =
-    this.options    =
-    this.enabled    =
-    this.timeout    =
-    this.hoverState =
-    this.$element   = null
-
-    this.init('tooltip', element, options)
-  }
-
-  Tooltip.VERSION  = '3.2.0'
-
-  Tooltip.DEFAULTS = {
-    animation: true,
-    placement: 'top',
-    selector: false,
-    template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
-    trigger: 'hover focus',
-    title: '',
-    delay: 0,
-    html: false,
-    container: false,
-    viewport: {
-      selector: 'body',
-      padding: 0
-    }
-  }
-
-  Tooltip.prototype.init = function (type, element, options) {
-    this.enabled   = true
-    this.type      = type
-    this.$element  = $(element)
-    this.options   = this.getOptions(options)
-    this.$viewport = this.options.viewport && $(this.options.viewport.selector || this.options.viewport)
-
-    var triggers = this.options.trigger.split(' ')
-
-    for (var i = triggers.length; i--;) {
-      var trigger = triggers[i]
-
-      if (trigger == 'click') {
-        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
-      } else if (trigger != 'manual') {
-        var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin'
-        var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
-
-        this.$element.on(eventIn  + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
-        this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
-      }
-    }
-
-    this.options.selector ?
-      (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
-      this.fixTitle()
-  }
-
-  Tooltip.prototype.getDefaults = function () {
-    return Tooltip.DEFAULTS
-  }
-
-  Tooltip.prototype.getOptions = function (options) {
-    options = $.extend({}, this.getDefaults(), this.$element.data(), options)
-
-    if (options.delay && typeof options.delay == 'number') {
-      options.delay = {
-        show: options.delay,
-        hide: options.delay
-      }
-    }
-
-    return options
-  }
-
-  Tooltip.prototype.getDelegateOptions = function () {
-    var options  = {}
-    var defaults = this.getDefaults()
-
-    this._options && $.each(this._options, function (key, value) {
-      if (defaults[key] != value) options[key] = value
-    })
-
-    return options
-  }
-
-  Tooltip.prototype.enter = function (obj) {
-    var self = obj instanceof this.constructor ?
-      obj : $(obj.currentTarget).data('bs.' + this.type)
-
-    if (!self) {
-      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
-      $(obj.currentTarget).data('bs.' + this.type, self)
-    }
-
-    clearTimeout(self.timeout)
-
-    self.hoverState = 'in'
-
-    if (!self.options.delay || !self.options.delay.show) return self.show()
-
-    self.timeout = setTimeout(function () {
-      if (self.hoverState == 'in') self.show()
-    }, self.options.delay.show)
-  }
-
-  Tooltip.prototype.leave = function (obj) {
-    var self = obj instanceof this.constructor ?
-      obj : $(obj.currentTarget).data('bs.' + this.type)
-
-    if (!self) {
-      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
-      $(obj.currentTarget).data('bs.' + this.type, self)
-    }
-
-    clearTimeout(self.timeout)
-
-    self.hoverState = 'out'
-
-    if (!self.options.delay || !self.options.delay.hide) return self.hide()
-
-    self.timeout = setTimeout(function () {
-      if (self.hoverState == 'out') self.hide()
-    }, self.options.delay.hide)
-  }
-
-  Tooltip.prototype.show = function () {
-    var e = $.Event('show.bs.' + this.type)
-
-    if (this.hasContent() && this.enabled) {
-      this.$element.trigger(e)
-
-      var inDom = $.contains(document.documentElement, this.$element[0])
-      if (e.isDefaultPrevented() || !inDom) return
-      var that = this
-
-      var $tip = this.tip()
-
-      var tipId = this.getUID(this.type)
-
-      this.setContent()
-      $tip.attr('id', tipId)
-      this.$element.attr('aria-describedby', tipId)
-
-      if (this.options.animation) $tip.addClass('fade')
-
-      var placement = typeof this.options.placement == 'function' ?
-        this.options.placement.call(this, $tip[0], this.$element[0]) :
-        this.options.placement
-
-      var autoToken = /\s?auto?\s?/i
-      var autoPlace = autoToken.test(placement)
-      if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
-
-      $tip
-        .detach()
-        .css({ top: 0, left: 0, display: 'block' })
-        .addClass(placement)
-        .data('bs.' + this.type, this)
-
-      this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
-
-      var pos          = this.getPosition()
-      var actualWidth  = $tip[0].offsetWidth
-      var actualHeight = $tip[0].offsetHeight
-
-      if (autoPlace) {
-        var orgPlacement = placement
-        var $parent      = this.$element.parent()
-        var parentDim    = this.getPosition($parent)
-
-        placement = placement == 'bottom' && pos.top   + pos.height       + actualHeight - parentDim.scroll > parentDim.height ? 'top'    :
-                    placement == 'top'    && pos.top   - parentDim.scroll - actualHeight < 0                                   ? 'bottom' :
-                    placement == 'right'  && pos.right + actualWidth      > parentDim.width                                    ? 'left'   :
-                    placement == 'left'   && pos.left  - actualWidth      < parentDim.left                                     ? 'right'  :
-                    placement
-
-        $tip
-          .removeClass(orgPlacement)
-          .addClass(placement)
-      }
-
-      var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
-
-      this.applyPlacement(calculatedOffset, placement)
-
-      var complete = function () {
-        that.$element.trigger('shown.bs.' + that.type)
-        that.hoverState = null
-      }
-
-      $.support.transition && this.$tip.hasClass('fade') ?
-        $tip
-          .one('bsTransitionEnd', complete)
-          .emulateTransitionEnd(150) :
-        complete()
-    }
-  }
-
-  Tooltip.prototype.applyPlacement = function (offset, placement) {
-    var $tip   = this.tip()
-    var width  = $tip[0].offsetWidth
-    var height = $tip[0].offsetHeight
-
-    // manually read margins because getBoundingClientRect includes difference
-    var marginTop = parseInt($tip.css('margin-top'), 10)
-    var marginLeft = parseInt($tip.css('margin-left'), 10)
-
-    // we must check for NaN for ie 8/9
-    if (isNaN(marginTop))  marginTop  = 0
-    if (isNaN(marginLeft)) marginLeft = 0
-
-    offset.top  = offset.top  + marginTop
-    offset.left = offset.left + marginLeft
-
-    // $.fn.offset doesn't round pixel values
-    // so we use setOffset directly with our own function B-0
-    $.offset.setOffset($tip[0], $.extend({
-      using: function (props) {
-        $tip.css({
-          top: Math.round(props.top),
-          left: Math.round(props.left)
-        })
-      }
-    }, offset), 0)
-
-    $tip.addClass('in')
-
-    // check to see if placing tip in new offset caused the tip to resize itself
-    var actualWidth  = $tip[0].offsetWidth
-    var actualHeight = $tip[0].offsetHeight
-
-    if (placement == 'top' && actualHeight != height) {
-      offset.top = offset.top + height - actualHeight
-    }
-
-    var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)
-
-    if (delta.left) offset.left += delta.left
-    else offset.top += delta.top
-
-    var arrowDelta          = delta.left ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
-    var arrowPosition       = delta.left ? 'left'        : 'top'
-    var arrowOffsetPosition = delta.left ? 'offsetWidth' : 'offsetHeight'
-
-    $tip.offset(offset)
-    this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], arrowPosition)
-  }
-
-  Tooltip.prototype.replaceArrow = function (delta, dimension, position) {
-    this.arrow().css(position, delta ? (50 * (1 - delta / dimension) + '%') : '')
-  }
-
-  Tooltip.prototype.setContent = function () {
-    var $tip  = this.tip()
-    var title = this.getTitle()
-
-    $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
-    $tip.removeClass('fade in top bottom left right')
-  }
-
-  Tooltip.prototype.hide = function () {
-    var that = this
-    var $tip = this.tip()
-    var e    = $.Event('hide.bs.' + this.type)
-
-    this.$element.removeAttr('aria-describedby')
-
-    function complete() {
-      if (that.hoverState != 'in') $tip.detach()
-      that.$element.trigger('hidden.bs.' + that.type)
-    }
-
-    this.$element.trigger(e)
-
-    if (e.isDefaultPrevented()) return
-
-    $tip.removeClass('in')
-
-    $.support.transition && this.$tip.hasClass('fade') ?
-      $tip
-        .one('bsTransitionEnd', complete)
-        .emulateTransitionEnd(150) :
-      complete()
-
-    this.hoverState = null
-
-    return this
-  }
-
-  Tooltip.prototype.fixTitle = function () {
-    var $e = this.$element
-    if ($e.attr('title') || typeof ($e.attr('data-original-title')) != 'string') {
-      $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
-    }
-  }
-
-  Tooltip.prototype.hasContent = function () {
-    return this.getTitle()
-  }
-
-  Tooltip.prototype.getPosition = function ($element) {
-    $element   = $element || this.$element
-    var el     = $element[0]
-    var isBody = el.tagName == 'BODY'
-    return $.extend({}, (typeof el.getBoundingClientRect == 'function') ? el.getBoundingClientRect() : null, {
-      scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop(),
-      width:  isBody ? $(window).width()  : $element.outerWidth(),
-      height: isBody ? $(window).height() : $element.outerHeight()
-    }, isBody ? { top: 0, left: 0 } : $element.offset())
-  }
-
-  Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
-    return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2  } :
-           placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2  } :
-           placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
-        /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width   }
-
-  }
-
-  Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
-    var delta = { top: 0, left: 0 }
-    if (!this.$viewport) return delta
-
-    var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
-    var viewportDimensions = this.getPosition(this.$viewport)
-
-    if (/right|left/.test(placement)) {
-      var topEdgeOffset    = pos.top - viewportPadding - viewportDimensions.scroll
-      var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight
-      if (topEdgeOffset < viewportDimensions.top) { // top overflow
-        delta.top = viewportDimensions.top - topEdgeOffset
-      } else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow
-        delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset
-      }
-    } else {
-      var leftEdgeOffset  = pos.left - viewportPadding
-      var rightEdgeOffset = pos.left + viewportPadding + actualWidth
-      if (leftEdgeOffset < viewportDimensions.left) { // left overflow
-        delta.left = viewportDimensions.left - leftEdgeOffset
-      } else if (rightEdgeOffset > viewportDimensions.width) { // right overflow
-        delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset
-      }
-    }
-
-    return delta
-  }
-
-  Tooltip.prototype.getTitle = function () {
-    var title
-    var $e = this.$element
-    var o  = this.options
-
-    title = $e.attr('data-original-title')
-      || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
-
-    return title
-  }
-
-  Tooltip.prototype.getUID = function (prefix) {
-    do prefix += ~~(Math.random() * 1000000)
-    while (document.getElementById(prefix))
-    return prefix
-  }
-
-  Tooltip.prototype.tip = function () {
-    return (this.$tip = this.$tip || $(this.options.template))
-  }
-
-  Tooltip.prototype.arrow = function () {
-    return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
-  }
-
-  Tooltip.prototype.validate = function () {
-    if (!this.$element[0].parentNode) {
-      this.hide()
-      this.$element = null
-      this.options  = null
-    }
-  }
-
-  Tooltip.prototype.enable = function () {
-    this.enabled = true
-  }
-
-  Tooltip.prototype.disable = function () {
-    this.enabled = false
-  }
-
-  Tooltip.prototype.toggleEnabled = function () {
-    this.enabled = !this.enabled
-  }
-
-  Tooltip.prototype.toggle = function (e) {
-    var self = this
-    if (e) {
-      self = $(e.currentTarget).data('bs.' + this.type)
-      if (!self) {
-        self = new this.constructor(e.currentTarget, this.getDelegateOptions())
-        $(e.currentTarget).data('bs.' + this.type, self)
-      }
-    }
-
-    self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
-  }
-
-  Tooltip.prototype.destroy = function () {
-    clearTimeout(this.timeout)
-    this.hide().$element.off('.' + this.type).removeData('bs.' + this.type)
-  }
-
-
-  // TOOLTIP PLUGIN DEFINITION
-  // =========================
-
-  function Plugin(option) {
-    return this.each(function () {
-      var $this   = $(this)
-      var data    = $this.data('bs.tooltip')
-      var options = typeof option == 'object' && option
-
-      if (!data && option == 'destroy') return
-      if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
-      if (typeof option == 'string') data[option]()
-    })
-  }
-
-  var old = $.fn.tooltip
-
-  $.fn.tooltip             = Plugin
-  $.fn.tooltip.Constructor = Tooltip
-
-
-  // TOOLTIP NO CONFLICT
-  // ===================
-
-  $.fn.tooltip.noConflict = function () {
-    $.fn.tooltip = old
-    return this
-  }
-
-}(jQuery);
+//+function ($) {
+//  'use strict';
+//
+//  // TOOLTIP PUBLIC CLASS DEFINITION
+//  // ===============================
+//
+//  var Tooltip = function (element, options) {
+//    this.type       =
+//    this.options    =
+//    this.enabled    =
+//    this.timeout    =
+//    this.hoverState =
+//    this.$element   = null
+//
+//    this.init('tooltip', element, options)
+//  }
+//
+//  Tooltip.VERSION  = '3.2.0'
+//
+//  Tooltip.DEFAULTS = {
+//    animation: true,
+//    placement: 'top',
+//    selector: false,
+//    template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
+//    trigger: 'hover focus',
+//    title: '',
+//    delay: 0,
+//    html: false,
+//    container: false,
+//    viewport: {
+//      selector: 'body',
+//      padding: 0
+//    }
+//  }
+//
+//  Tooltip.prototype.init = function (type, element, options) {
+//    this.enabled   = true
+//    this.type      = type
+//    this.$element  = $(element)
+//    this.options   = this.getOptions(options)
+//    this.$viewport = this.options.viewport && $(this.options.viewport.selector || this.options.viewport)
+//
+//    var triggers = this.options.trigger.split(' ')
+//
+//    for (var i = triggers.length; i--;) {
+//      var trigger = triggers[i]
+//
+//      if (trigger == 'click') {
+//        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
+//      } else if (trigger != 'manual') {
+//        var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin'
+//        var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
+//
+//        this.$element.on(eventIn  + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
+//        this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
+//      }
+//    }
+//
+//    this.options.selector ?
+//      (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
+//      this.fixTitle()
+//  }
+//
+//  Tooltip.prototype.getDefaults = function () {
+//    return Tooltip.DEFAULTS
+//  }
+//
+//  Tooltip.prototype.getOptions = function (options) {
+//    options = $.extend({}, this.getDefaults(), this.$element.data(), options)
+//
+//    if (options.delay && typeof options.delay == 'number') {
+//      options.delay = {
+//        show: options.delay,
+//        hide: options.delay
+//      }
+//    }
+//
+//    return options
+//  }
+//
+//  Tooltip.prototype.getDelegateOptions = function () {
+//    var options  = {}
+//    var defaults = this.getDefaults()
+//
+//    this._options && $.each(this._options, function (key, value) {
+//      if (defaults[key] != value) options[key] = value
+//    })
+//
+//    return options
+//  }
+//
+//  Tooltip.prototype.enter = function (obj) {
+//    var self = obj instanceof this.constructor ?
+//      obj : $(obj.currentTarget).data('bs.' + this.type)
+//
+//    if (!self) {
+//      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
+//      $(obj.currentTarget).data('bs.' + this.type, self)
+//    }
+//
+//    clearTimeout(self.timeout)
+//
+//    self.hoverState = 'in'
+//
+//    if (!self.options.delay || !self.options.delay.show) return self.show()
+//
+//    self.timeout = setTimeout(function () {
+//      if (self.hoverState == 'in') self.show()
+//    }, self.options.delay.show)
+//  }
+//
+//  Tooltip.prototype.leave = function (obj) {
+//    var self = obj instanceof this.constructor ?
+//      obj : $(obj.currentTarget).data('bs.' + this.type)
+//
+//    if (!self) {
+//      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
+//      $(obj.currentTarget).data('bs.' + this.type, self)
+//    }
+//
+//    clearTimeout(self.timeout)
+//
+//    self.hoverState = 'out'
+//
+//    if (!self.options.delay || !self.options.delay.hide) return self.hide()
+//
+//    self.timeout = setTimeout(function () {
+//      if (self.hoverState == 'out') self.hide()
+//    }, self.options.delay.hide)
+//  }
+//
+//  Tooltip.prototype.show = function () {
+//    var e = $.Event('show.bs.' + this.type)
+//
+//    if (this.hasContent() && this.enabled) {
+//      this.$element.trigger(e)
+//
+//      var inDom = $.contains(document.documentElement, this.$element[0])
+//      if (e.isDefaultPrevented() || !inDom) return
+//      var that = this
+//
+//      var $tip = this.tip()
+//
+//      var tipId = this.getUID(this.type)
+//
+//      this.setContent()
+//      $tip.attr('id', tipId)
+//      this.$element.attr('aria-describedby', tipId)
+//
+//      if (this.options.animation) $tip.addClass('fade')
+//
+//      var placement = typeof this.options.placement == 'function' ?
+//        this.options.placement.call(this, $tip[0], this.$element[0]) :
+//        this.options.placement
+//
+//      var autoToken = /\s?auto?\s?/i
+//      var autoPlace = autoToken.test(placement)
+//      if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
+//
+//      $tip
+//        .detach()
+//        .css({ top: 0, left: 0, display: 'block' })
+//        .addClass(placement)
+//        .data('bs.' + this.type, this)
+//
+//      this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
+//
+//      var pos          = this.getPosition()
+//      var actualWidth  = $tip[0].offsetWidth
+//      var actualHeight = $tip[0].offsetHeight
+//
+//      if (autoPlace) {
+//        var orgPlacement = placement
+//        var $parent      = this.$element.parent()
+//        var parentDim    = this.getPosition($parent)
+//
+//        placement = placement == 'bottom' && pos.top   + pos.height       + actualHeight - parentDim.scroll > parentDim.height ? 'top'    :
+//                    placement == 'top'    && pos.top   - parentDim.scroll - actualHeight < 0                                   ? 'bottom' :
+//                    placement == 'right'  && pos.right + actualWidth      > parentDim.width                                    ? 'left'   :
+//                    placement == 'left'   && pos.left  - actualWidth      < parentDim.left                                     ? 'right'  :
+//                    placement
+//
+//        $tip
+//          .removeClass(orgPlacement)
+//          .addClass(placement)
+//      }
+//
+//      var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
+//
+//      this.applyPlacement(calculatedOffset, placement)
+//
+//      var complete = function () {
+//        that.$element.trigger('shown.bs.' + that.type)
+//        that.hoverState = null
+//      }
+//
+//      $.support.transition && this.$tip.hasClass('fade') ?
+//        $tip
+//          .one('bsTransitionEnd', complete)
+//          .emulateTransitionEnd(150) :
+//        complete()
+//    }
+//  }
+//
+//  Tooltip.prototype.applyPlacement = function (offset, placement) {
+//    var $tip   = this.tip()
+//    var width  = $tip[0].offsetWidth
+//    var height = $tip[0].offsetHeight
+//
+//    // manually read margins because getBoundingClientRect includes difference
+//    var marginTop = parseInt($tip.css('margin-top'), 10)
+//    var marginLeft = parseInt($tip.css('margin-left'), 10)
+//
+//    // we must check for NaN for ie 8/9
+//    if (isNaN(marginTop))  marginTop  = 0
+//    if (isNaN(marginLeft)) marginLeft = 0
+//
+//    offset.top  = offset.top  + marginTop
+//    offset.left = offset.left + marginLeft
+//
+//    // $.fn.offset doesn't round pixel values
+//    // so we use setOffset directly with our own function B-0
+//    $.offset.setOffset($tip[0], $.extend({
+//      using: function (props) {
+//        $tip.css({
+//          top: Math.round(props.top),
+//          left: Math.round(props.left)
+//        })
+//      }
+//    }, offset), 0)
+//
+//    $tip.addClass('in')
+//
+//    // check to see if placing tip in new offset caused the tip to resize itself
+//    var actualWidth  = $tip[0].offsetWidth
+//    var actualHeight = $tip[0].offsetHeight
+//
+//    if (placement == 'top' && actualHeight != height) {
+//      offset.top = offset.top + height - actualHeight
+//    }
+//
+//    var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)
+//
+//    if (delta.left) offset.left += delta.left
+//    else offset.top += delta.top
+//
+//    var arrowDelta          = delta.left ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
+//    var arrowPosition       = delta.left ? 'left'        : 'top'
+//    var arrowOffsetPosition = delta.left ? 'offsetWidth' : 'offsetHeight'
+//
+//    $tip.offset(offset)
+//    this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], arrowPosition)
+//  }
+//
+//  Tooltip.prototype.replaceArrow = function (delta, dimension, position) {
+//    this.arrow().css(position, delta ? (50 * (1 - delta / dimension) + '%') : '')
+//  }
+//
+//  Tooltip.prototype.setContent = function () {
+//    var $tip  = this.tip()
+//    var title = this.getTitle()
+//
+//    $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
+//    $tip.removeClass('fade in top bottom left right')
+//  }
+//
+//  Tooltip.prototype.hide = function () {
+//    var that = this
+//    var $tip = this.tip()
+//    var e    = $.Event('hide.bs.' + this.type)
+//
+//    this.$element.removeAttr('aria-describedby')
+//
+//    function complete() {
+//      if (that.hoverState != 'in') $tip.detach()
+//      that.$element.trigger('hidden.bs.' + that.type)
+//    }
+//
+//    this.$element.trigger(e)
+//
+//    if (e.isDefaultPrevented()) return
+//
+//    $tip.removeClass('in')
+//
+//    $.support.transition && this.$tip.hasClass('fade') ?
+//      $tip
+//        .one('bsTransitionEnd', complete)
+//        .emulateTransitionEnd(150) :
+//      complete()
+//
+//    this.hoverState = null
+//
+//    return this
+//  }
+//
+//  Tooltip.prototype.fixTitle = function () {
+//    var $e = this.$element
+//    if ($e.attr('title') || typeof ($e.attr('data-original-title')) != 'string') {
+//      $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
+//    }
+//  }
+//
+//  Tooltip.prototype.hasContent = function () {
+//    return this.getTitle()
+//  }
+//
+//  Tooltip.prototype.getPosition = function ($element) {
+//    $element   = $element || this.$element
+//    var el     = $element[0]
+//    var isBody = el.tagName == 'BODY'
+//    return $.extend({}, (typeof el.getBoundingClientRect == 'function') ? el.getBoundingClientRect() : null, {
+//      scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop(),
+//      width:  isBody ? $(window).width()  : $element.outerWidth(),
+//      height: isBody ? $(window).height() : $element.outerHeight()
+//    }, isBody ? { top: 0, left: 0 } : $element.offset())
+//  }
+//
+//  Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
+//    return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2  } :
+//           placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2  } :
+//           placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
+//        /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width   }
+//
+//  }
+//
+//  Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
+//    var delta = { top: 0, left: 0 }
+//    if (!this.$viewport) return delta
+//
+//    var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
+//    var viewportDimensions = this.getPosition(this.$viewport)
+//
+//    if (/right|left/.test(placement)) {
+//      var topEdgeOffset    = pos.top - viewportPadding - viewportDimensions.scroll
+//      var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight
+//      if (topEdgeOffset < viewportDimensions.top) { // top overflow
+//        delta.top = viewportDimensions.top - topEdgeOffset
+//      } else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow
+//        delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset
+//      }
+//    } else {
+//      var leftEdgeOffset  = pos.left - viewportPadding
+//      var rightEdgeOffset = pos.left + viewportPadding + actualWidth
+//      if (leftEdgeOffset < viewportDimensions.left) { // left overflow
+//        delta.left = viewportDimensions.left - leftEdgeOffset
+//      } else if (rightEdgeOffset > viewportDimensions.width) { // right overflow
+//        delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset
+//      }
+//    }
+//
+//    return delta
+//  }
+//
+//  Tooltip.prototype.getTitle = function () {
+//    var title
+//    var $e = this.$element
+//    var o  = this.options
+//
+//    title = $e.attr('data-original-title')
+//      || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
+//
+//    return title
+//  }
+//
+//  Tooltip.prototype.getUID = function (prefix) {
+//    do prefix += ~~(Math.random() * 1000000)
+//    while (document.getElementById(prefix))
+//    return prefix
+//  }
+//
+//  Tooltip.prototype.tip = function () {
+//    return (this.$tip = this.$tip || $(this.options.template))
+//  }
+//
+//  Tooltip.prototype.arrow = function () {
+//    return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
+//  }
+//
+//  Tooltip.prototype.validate = function () {
+//    if (!this.$element[0].parentNode) {
+//      this.hide()
+//      this.$element = null
+//      this.options  = null
+//    }
+//  }
+//
+//  Tooltip.prototype.enable = function () {
+//    this.enabled = true
+//  }
+//
+//  Tooltip.prototype.disable = function () {
+//    this.enabled = false
+//  }
+//
+//  Tooltip.prototype.toggleEnabled = function () {
+//    this.enabled = !this.enabled
+//  }
+//
+//  Tooltip.prototype.toggle = function (e) {
+//    var self = this
+//    if (e) {
+//      self = $(e.currentTarget).data('bs.' + this.type)
+//      if (!self) {
+//        self = new this.constructor(e.currentTarget, this.getDelegateOptions())
+//        $(e.currentTarget).data('bs.' + this.type, self)
+//      }
+//    }
+//
+//    self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
+//  }
+//
+//  Tooltip.prototype.destroy = function () {
+//    clearTimeout(this.timeout)
+//    this.hide().$element.off('.' + this.type).removeData('bs.' + this.type)
+//  }
+//
+//
+//  // TOOLTIP PLUGIN DEFINITION
+//  // =========================
+//
+//  function Plugin(option) {
+//    return this.each(function () {
+//      var $this   = $(this)
+//      var data    = $this.data('bs.tooltip')
+//      var options = typeof option == 'object' && option
+//
+//      if (!data && option == 'destroy') return
+//      if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
+//      if (typeof option == 'string') data[option]()
+//    })
+//  }
+//
+//  var old = $.fn.tooltip
+//
+//  $.fn.tooltip             = Plugin
+//  $.fn.tooltip.Constructor = Tooltip
+//
+//
+//  // TOOLTIP NO CONFLICT
+//  // ===================
+//
+//  $.fn.tooltip.noConflict = function () {
+//    $.fn.tooltip = old
+//    return this
+//  }
+//
+//}(jQuery);
 
 /* ========================================================================
  * Bootstrap: popover.js v3.2.0
@@ -5607,110 +5607,110 @@ if (typeof jQuery === 'undefined') { throw new Error('Bootstrap\'s JavaScript re
  * ======================================================================== */
 
 
-+function ($) {
-  'use strict';
-
-  // POPOVER PUBLIC CLASS DEFINITION
-  // ===============================
-
-  var Popover = function (element, options) {
-    this.init('popover', element, options)
-  }
-
-  if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
-
-  Popover.VERSION  = '3.2.0'
-
-  Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
-    placement: 'right',
-    trigger: 'click',
-    content: '',
-    template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
-  })
-
-
-  // NOTE: POPOVER EXTENDS tooltip.js
-  // ================================
-
-  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
-
-  Popover.prototype.constructor = Popover
-
-  Popover.prototype.getDefaults = function () {
-    return Popover.DEFAULTS
-  }
-
-  Popover.prototype.setContent = function () {
-    var $tip    = this.tip()
-    var title   = this.getTitle()
-    var content = this.getContent()
-
-    $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
-    $tip.find('.popover-content').empty()[ // we use append for html objects to maintain js events
-      this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'
-    ](content)
-
-    $tip.removeClass('fade top bottom left right in')
-
-    // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
-    // this manually by checking the contents.
-    if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
-  }
-
-  Popover.prototype.hasContent = function () {
-    return this.getTitle() || this.getContent()
-  }
-
-  Popover.prototype.getContent = function () {
-    var $e = this.$element
-    var o  = this.options
-
-    return $e.attr('data-content')
-      || (typeof o.content == 'function' ?
-            o.content.call($e[0]) :
-            o.content)
-  }
-
-  Popover.prototype.arrow = function () {
-    return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
-  }
-
-  Popover.prototype.tip = function () {
-    if (!this.$tip) this.$tip = $(this.options.template)
-    return this.$tip
-  }
-
-
-  // POPOVER PLUGIN DEFINITION
-  // =========================
-
-  function Plugin(option) {
-    return this.each(function () {
-      var $this   = $(this)
-      var data    = $this.data('bs.popover')
-      var options = typeof option == 'object' && option
-
-      if (!data && option == 'destroy') return
-      if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
-      if (typeof option == 'string') data[option]()
-    })
-  }
-
-  var old = $.fn.popover
-
-  $.fn.popover             = Plugin
-  $.fn.popover.Constructor = Popover
-
-
-  // POPOVER NO CONFLICT
-  // ===================
-
-  $.fn.popover.noConflict = function () {
-    $.fn.popover = old
-    return this
-  }
-
-}(jQuery);
+//+function ($) {
+//  'use strict';
+//
+//  // POPOVER PUBLIC CLASS DEFINITION
+//  // ===============================
+//
+//  var Popover = function (element, options) {
+//    this.init('popover', element, options)
+//  }
+//
+//  if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
+//
+//  Popover.VERSION  = '3.2.0'
+//
+//  Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
+//    placement: 'right',
+//    trigger: 'click',
+//    content: '',
+//    template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
+//  })
+//
+//
+//  // NOTE: POPOVER EXTENDS tooltip.js
+//  // ================================
+//
+//  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
+//
+//  Popover.prototype.constructor = Popover
+//
+//  Popover.prototype.getDefaults = function () {
+//    return Popover.DEFAULTS
+//  }
+//
+//  Popover.prototype.setContent = function () {
+//    var $tip    = this.tip()
+//    var title   = this.getTitle()
+//    var content = this.getContent()
+//
+//    $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
+//    $tip.find('.popover-content').empty()[ // we use append for html objects to maintain js events
+//      this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'
+//    ](content)
+//
+//    $tip.removeClass('fade top bottom left right in')
+//
+//    // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
+//    // this manually by checking the contents.
+//    if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
+//  }
+//
+//  Popover.prototype.hasContent = function () {
+//    return this.getTitle() || this.getContent()
+//  }
+//
+//  Popover.prototype.getContent = function () {
+//    var $e = this.$element
+//    var o  = this.options
+//
+//    return $e.attr('data-content')
+//      || (typeof o.content == 'function' ?
+//            o.content.call($e[0]) :
+//            o.content)
+//  }
+//
+//  Popover.prototype.arrow = function () {
+//    return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
+//  }
+//
+//  Popover.prototype.tip = function () {
+//    if (!this.$tip) this.$tip = $(this.options.template)
+//    return this.$tip
+//  }
+//
+//
+//  // POPOVER PLUGIN DEFINITION
+//  // =========================
+//
+//  function Plugin(option) {
+//    return this.each(function () {
+//      var $this   = $(this)
+//      var data    = $this.data('bs.popover')
+//      var options = typeof option == 'object' && option
+//
+//      if (!data && option == 'destroy') return
+//      if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
+//      if (typeof option == 'string') data[option]()
+//    })
+//  }
+//
+//  var old = $.fn.popover
+//
+//  $.fn.popover             = Plugin
+//  $.fn.popover.Constructor = Popover
+//
+//
+//  // POPOVER NO CONFLICT
+//  // ===================
+//
+//  $.fn.popover.noConflict = function () {
+//    $.fn.popover = old
+//    return this
+//  }
+//
+//}(jQuery);
 
 /* ========================================================================
  * Bootstrap: scrollspy.js v3.2.0
diff --git a/js/importSTL.js b/js/importMenu.js
similarity index 70%
rename from js/importSTL.js
rename to js/importMenu.js
index f4f1d5c284246322dfb009e28a483272b473ed7e..59c2ad6cb8e248defc8682ec68faec5515f2e711 100644
--- a/js/importSTL.js
+++ b/js/importMenu.js
@@ -6,15 +6,16 @@
 
 $(function(){
 
-    threeMain = threeMain || {};
+    three = three || {};
 
     function loadSTL(file){
-
         var loader = new THREE.STLLoader();
   	    loader.addEventListener( 'load', function (e) {
   		    var geometry = e.content;
-  		    threeMain.scene.add( new THREE.Mesh( geometry ) );
-            threeMain.render();
+            three.clearAll();
+  		    three.scene.add( new THREE.Mesh( geometry ) );
+            three.render();
+            $("#STLImportStats").fadeIn();
         });
 
   	    loader.load(file);
@@ -39,9 +40,21 @@ $(function(){
          reader.onload = (function() {
             return function(e) {
                 loadSTL(e.target.result);
+                setFileName(label);
             }
         })();
-        console.log("loaded" + label);
+        console.log("loaded " + label);
      });
 
+    $('#ex1').slider({
+	    formatter: function(value) {
+		    return value;
+	    }
+    });
+
+    function setFileName(name){
+        $("#STLFilename").html("Current file loaded:&nbsp&nbsp"+name);
+    }
+
+
 });
\ No newline at end of file
diff --git a/js/main.js b/js/main.js
index ac05f047a73ab805ab7261f38e1ba34b946d2a1f..f01950f830629fb7f363bcbbe96521c88608be29 100644
--- a/js/main.js
+++ b/js/main.js
@@ -7,7 +7,7 @@ var Parallel = Parallel || {};
 
 $(function(){
 
-    threeMain = ThreeMain();
-    setupNavBar(threeMain);
+    three = Three();
+    setupNavBar();
 
 });
diff --git a/js/navbar.js b/js/navbar.js
index 9cd50a99404ed36050a08311754f1c59ff6dd7de..301bbb22be8113f74a7182829c22c15147b83963 100644
--- a/js/navbar.js
+++ b/js/navbar.js
@@ -2,7 +2,8 @@
  * Created by aghassaei on 1/7/15.
  */
 
-function setupNavBar(threeSpace){
+
+function setupNavBar(){
 
     var allMenus = $(".navMenu");
     var allNavMenuLinks = $(".menuHoverControls");
@@ -41,15 +42,6 @@ function setupNavBar(threeSpace){
     });
 
     //clear canvas
-    $("#clearAll").click(function(){
-        var children = threeSpace.scene.children;
-        for (var i=children.length;i>=0;i--){
-            var object = children[i];
-            if (object instanceof THREE.Mesh){
-                threeSpace.scene.remove(object);
-            }
-        }
-        threeSpace.render();
-    });
+    $("#clearAll").click(three.clearAll);
 
 }
\ No newline at end of file
diff --git a/js/threeMain.js b/js/threeMain.js
index 753a6cc3ec617ffe9aeb762cf7cf89e246dddb41..a72319cf9b3c3e56ce2a7874601d606483afc2ef 100644
--- a/js/threeMain.js
+++ b/js/threeMain.js
@@ -2,7 +2,7 @@
  * Created by aghassaei on 1/8/15.
  */
 
-function ThreeMain(){
+function Three(){
 
     var self = this;
 
@@ -80,12 +80,24 @@ function ThreeMain(){
         
       renderer.render( scene, camera );
     }
+
+    function clearAll(){
+        var children = scene.children;
+        for (var i=children.length;i>=0;i--){
+            var object = children[i];
+            if (object instanceof THREE.Mesh){
+                scene.remove(object);
+            }
+        }
+        render();
+    }
     
     return {//public properties
         scene:scene,
 //        camera:camera,
 //        controls:controls,
 //        renderer:renderer,
-        render:render
+        render:render,
+        clearAll:clearAll
     }
 }
\ No newline at end of file
diff --git a/main.html b/main.html
index feee32e2ac298239f1a8836104db2b23042ca38b..dbb92c10771d50a54ed37dcc772d0f41c5bcf209 100644
--- a/main.html
+++ b/main.html
@@ -14,15 +14,14 @@
 
     <!--flatUI bootstrap theme-->
     <link href="dependencies/flatUI/css/vendor/bootstrap.min.css" rel="stylesheet"><!-- Loading Bootstrap -->
-    <link href="dependencies/flatUI/css/flat-ui.min.css" rel="stylesheet"><!-- Loading Flat UI -->
-    <!-- HTML5 shim, for IE6-8 support of HTML5 elements. All other JS at the end of file. -->
-    <!--[if lt IE 9]>
-      <script src="dependencies/flatUI/js/vendor/html5shiv.js"></script>
-      <script src="dependencies/flatUI/js/vendor/respond.min.js"></script>
-    <![endif]-->
-    <script src="dependencies/flatUI/js/flat-ui.min.js"></script>
+    <link href="dependencies/flatUI/css/flat-ui.css" rel="stylesheet"><!-- Loading Flat UI -->
+    <script src="dependencies/flatUI/js/flat-ui.js"></script>
     <!--<script src="dependencies/flatUI/js/vendor/video.js"></script>-->
 
+    <!--bootstrap slider-->
+    <link href="dependencies/bootstrap-slider/bootstrap-slider.css" rel="stylesheet">
+    <script src="dependencies/bootstrap-slider/bootstrap-slider.js"></script>
+
     <!--threeJS-->
     <script src="dependencies/three.js"></script>
     <script src="dependencies/OrbitControls.js"></script>
@@ -33,7 +32,7 @@
 
     <script src="js/main.js"></script>
     <script src="dependencies/loaders/STLLoader.js"></script>
-    <script src="js/importSTL.js"></script>
+    <script src="js/importMenu.js"></script>
     <link rel="stylesheet" type="text/css" href="css/main.css">
 
 </head>
@@ -75,28 +74,33 @@
     <div class="row demo-row">
         <div class="col-xs-3">
         <div>
-           <span class="btn btn-default btn-file">
+           <span class="btn btn-default btn-file fullWidth">
                 Upload STL<input id="uploadSTL" type="file">
            </span>
         </div>
-        <div>
+        <div class="text-center">
             OR
         </div>
         <div>
-          <div class="btn-group">
-            <button data-toggle="dropdown" class="btn btn-primary dropdown-toggle" type="button">Select Model <span class="caret"></span></button>
+          <div class="btn-group fullWidth">
+            <button data-toggle="dropdown" class="btn btn-primary dropdown-toggle fullWidth" type="button">Select Model <span class="caret"></span></button>
             <ul role="menu" class="dropdown-menu">
               <li><a class="stlImport" data-file="Airbus_A300-600.stl" href="#">Plane</a></li>
             </ul>
           </div><!-- /btn-group -->
         </div>
         </div> <!-- /.col-xs-3 -->
+        <div id="STLImportStats" class="col-xs-8">
+            <div id="STLFilename"></div><br/>Dimensions:<br/>
+            Change model scale:
+            <input id="ex1" data-slider-id='ex1Slider' type="text" data-slider-min="0.0" data-slider-max="20" data-slider-step="0.1" data-slider-value="1"/>
+        </div>
     </div>
 </div>
 <div id="element" class="row navMenu">
     <div class="row demo-row">
         <div class="col-xs-3">
-           afsdf
+           <a id="elementCube" href="#">Cube</a>
         </div>
     </div>
 </div>
@@ -122,7 +126,7 @@
         <div class="progress-bar progress-bar-info" style="width: 10%;"></div>
       </div>
       <br>
-      <div id="slider" class="ui-slider ui-slider-horizontal ui-widget ui-widget-content ui-corner-all" aria-disabled="false"><div class="ui-slider-segment" style="margin-left: 25%;"></div><div class="ui-slider-segment" style="margin-left: 25%;"></div><div class="ui-slider-segment" style="margin-left: 25%;"></div>
+      <div id="slider1" class="ui-slider ui-slider-horizontal ui-widget ui-widget-content ui-corner-all" aria-disabled="false"><div class="ui-slider-segment" style="margin-left: 25%;"></div><div class="ui-slider-segment" style="margin-left: 25%;"></div><div class="ui-slider-segment" style="margin-left: 25%;"></div>
         <div class="ui-slider-segment"></div>
         <div class="ui-slider-segment"></div>
         <div class="ui-slider-segment"></div>