diff --git a/vcm/config.json b/vcm/config.json index 7ddc8cf6e320b1b3711b2ff100a5f63aa7a1fade..27ca432673ebccd4c6a3dd13da0ac3517d1bf8df 100644 --- a/vcm/config.json +++ b/vcm/config.json @@ -445,10 +445,10 @@ },{ "template": [ "<div class='balloon' style='width: 200px; background-color: #3C3C3C; color: #FFFFFF;' id='myBalloonNord'>", + " <button class='infobtn' onclick='NordbahnhofText()'></button>", " <h1 class='balloon-title' style='color: #FFFFFF;'>Nordbahnhof Planungskonzept</h1>", " <div class='balloon-content' style='margin-right: 0px;'", " </div>", - "<p class='balloon-text'><span>Für mehr Infos klicken Sie bitte hier!</span><br></p>", "<div class='box-3'>", "<div class='btn btn-three' onclick='newPlan()'>", "<span>Neue Planung</span>", diff --git a/vcm/datasource-data/PartOfStuggiWithAll/data/data0.b3dm b/vcm/datasource-data/PartOfStuggiWithAll/data/data0.b3dm new file mode 100644 index 0000000000000000000000000000000000000000..4854f0678b2bb5609e9d5378800c242cceadf01d Binary files /dev/null and b/vcm/datasource-data/PartOfStuggiWithAll/data/data0.b3dm differ diff --git a/vcm/datasource-data/PartOfStuggiWithAll/tileset.json b/vcm/datasource-data/PartOfStuggiWithAll/tileset.json new file mode 100644 index 0000000000000000000000000000000000000000..f67c8871f9594e13fb3e5d8c215a99c7f72785d5 --- /dev/null +++ b/vcm/datasource-data/PartOfStuggiWithAll/tileset.json @@ -0,0 +1,84 @@ +{ + "asset" : { + "version" : "0.0" + }, + "properties" : { + "gml_id" : {}, + "gml_parent_id" : {}, + "citygml_target_uri" : {}, + "citygml_feature_role" : {}, + "citygml_feature_role_attr_name" : {}, + "citygml_feature_role_attr_val" : {}, + "gml_description" : {}, + "gml_name" : {}, + "citygml_creationDate" : {}, + "citygml_terminationDate" : {}, + "externalReference{}.externalObject.name" : {}, + "externalReference{}.externalObject.uri" : {}, + "externalReference{}.informationSystem" : {}, + "citygml_generalizes_to{}.xlink_href" : {}, + "citygml_relative_to_terrain" : {}, + "citygml_relative_to_water" : {}, + "citygml_appearance{}.xlink_href" : {}, + "citygml_class" : {}, + "citygml_class_codeSpace" : {}, + "citygml_function{}" : {}, + "citygml_function{}.codeSpace" : {}, + "citygml_usage{}" : {}, + "citygml_usage{}.codeSpace" : {}, + "citygml_year_of_construction" : {}, + "citygml_year_of_demolition" : {}, + "citygml_roof_type" : {}, + "citygml_roof_type_codeSpace" : {}, + "citygml_measured_height" : { + "minimum" : 1.6, + "maximum" : 24.3 + }, + "citygml_measured_height_units" : {}, + "citygml_storeys_above_ground" : {}, + "citygml_storeys_below_ground" : {}, + "citygml_storey_heights_above_ground" : {}, + "citygml_storey_heights_above_ground_units" : {}, + "citygml_storey_heights_below_ground" : {}, + "citygml_storey_heights_below_ground_units" : {}, + "citygml_outer_building_installation{}.xlink_href" : {}, + "citygml_interior_building_installation{}.xlink_href" : {}, + "citygml_bounded_by{}.xlink_href" : {}, + "citygml_level_of_detail{}" : {}, + "citygml_interior_room{}.xlink_href" : {}, + "citygml_consists_of_building_part{}.xlink_href" : {}, + "citygml_address{}.xlink_href" : {}, + "LoD1_datenquelleBodenhoehe" : {}, + "LoD1_datenquelleLage" : {}, + "alkisId" : {}, + "anzahlDerDreiBisVierZimmerWohnungen" : {}, + "anzahlDerFuenfUndMehrZimmerWohnungen" : {}, + "baublockNummer" : {}, + "baublockseitenNummer" : {}, + "dachgeschossausbau" : {}, + "gebaeudekennzeichen_1" : {}, + "gebaeudekennzeichen_2" : {}, + "geschossflaeche" : {}, + "gmlIdALKISLageBezeichnung_1" : {}, + "gmlIdALKISLageBezeichnung_2" : {}, + "grundflaeche" : {}, + "hoeheEFH" : {}, + "hoeheFirst" : {}, + "hoeheTrauf" : {}, + "statusDesGebaeudes" : {}, + "umbauterRaum" : {} + }, + "geometricError" : 225.65855423675384, + "root" : { + "boundingVolume" : { + "box" : [ 4155305.234884402, 672842.5487232395, 4775768.442179372, 668.5917059811763, 0, 0, 0, 783.0869944699807, 0, 0, 0, 580.2606065925211 ] + }, + "refine" : "ADD", + "content" : { + "boundingVolume" : { + "box" : [ 4155305.234884402, 672842.5487232395, 4775768.442179372, 668.5917059811763, 0, 0, 0, 783.0869944699807, 0, 0, 0, 580.2606065925211 ] + }, + "url" : "data/data0.b3dm" + } + } +} \ No newline at end of file diff --git a/vcm/images/Info.svg b/vcm/images/Info.svg new file mode 100644 index 0000000000000000000000000000000000000000..fa5250186119944f661860e7196b92e07cdfb4a8 --- /dev/null +++ b/vcm/images/Info.svg @@ -0,0 +1 @@ +<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 300 300"><defs><style>.cls-1{stroke:#000;stroke-width:7px;opacity:0.11;}.cls-1,.cls-3{stroke-miterlimit:10;}.cls-2{fill:#fff;}.cls-3{fill:none;stroke:#fff;stroke-width:10px;}</style></defs><title>locationArtboard 1</title><circle class="cls-1" cx="150" cy="150" r="142"/><path class="cls-2" d="M116.53,249.71v-9.06c20.37-1.94,22.64-3.56,22.64-25.55V148.48c0-20-1-21.35-20.38-24.58v-7.76a211.88,211.88,0,0,0,45.93-12.94V215.1c0,22,2.26,23.61,23.28,25.55v9.06Zm33.63-178.2c-9,0-17.14-8.09-17.14-17.14a17.47,17.47,0,0,1,17.47-17.79c9,0,16.49,7.44,16.49,17.79C167,63.42,159.54,71.51,150.16,71.51Z"/><circle class="cls-3" cx="151" cy="150" r="142"/></svg> \ No newline at end of file diff --git a/vcm/index.html b/vcm/index.html index 44a7676c7a7899d62a97ff1ec40686e7f61b0fd3..c5cde2e2a2b42c07f886055513391520b43f6d3d 100644 --- a/vcm/index.html +++ b/vcm/index.html @@ -151,6 +151,7 @@ <link rel="stylesheet" href="templates/custom.css"> <link rel="stylesheet" href="templates/story/story.css"> <link rel="stylesheet" href="templates/cus_Menu.css"> + <link rel="stylesheet" href="sources/nouislider.css"> </head> @@ -529,7 +530,36 @@ </div> </div> </div> - + <!-- ======================================================================================================================================================================== --> + <!-- Nordbahnhof --> + <div id="NordbahnhofInfo" class="SideInfo" style="display:none;"> + <h1 class="sticky" id="headNordB">Nordbahnhof</h1> + + <p class="contentOne">Im Nordbahnhof Areal ist ein Neubau geplant. Dieser kann in verschiedenen Aspekten mit den bestehenden Bauten verglichen werden. + Der Energie Nutzungs Aspekt kann nur bedingt herangezogen werden, da die Gebäude sehr unterschiedliche Nutzungen haben. Hier würde es sich anbieten verschiedene Planungen aufgrund ihrer Energienutzung zu vergleichen. + </p> + <br> + <h2>Specific Space Heating Demand</h2> + <p>The specific space heating demand wurde mit SimStadt simuliert. Die Werte sind in [kWh/m²·a] angegeben.</p><br> + <div id="unconstrained"></div><br> + <span class="example-val" id="unconstrained-values"></span> + + <div class='my-legend'> + <div class='legend-title'>in [kWh/m²·a] </div> + <div class='legend-scale'> + <ul class='legend-labels'> + <li id="One"><span class="rectangle" style='background:#38943d;'></span>min-100</li> + <li id="Two"><span class="rectangle" style='background:#699438;'></span>100-200</li> + <li id="Three"><span class="rectangle" style='background:#d0d40b;'></span>200-300</li> + <li id="Four"><span class="rectangle" style='background:#db6f09;'></span>300-400</li> + <li id="Five"><span class="rectangle" style='background:#ad0202;'></span>400-max</li> + </ul> + </div> + <!-- <div class='legend-source'>Source: <a href="#link to source">Name of source</a></div> --> + </div> + <!-- <div id="slider-color"></div> --> + </div> + </div> <div id="tour-button" title="Karte/Story umschalten"> <i class="fa"></i> @@ -548,6 +578,9 @@ <script src="lib/Cesium/Cesium.js"></script> <script src='lib/vcm_thirdparty.js'></script> <script src="lib/vcm-compiled_api.js"></script> + <script src="sources/nouislider.js"></script> + <script src="templates/slider.js"></script> + <link href="templates/sliders.css" rel="stylesheet"> <script> var startVCM = function() { diff --git a/vcm/sources/nouislider.css b/vcm/sources/nouislider.css new file mode 100644 index 0000000000000000000000000000000000000000..fffd3410f05290dd6a8f4e1be6e298bb17b3b8df --- /dev/null +++ b/vcm/sources/nouislider.css @@ -0,0 +1,310 @@ +/*! nouislider - 14.6.0 - 6/27/2020 */ +/* Functional styling; + * These styles are required for noUiSlider to function. + * You don't need to change these rules to apply your design. + */ +.noUi-target, +.noUi-target * { + -webkit-touch-callout: none; + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); + -webkit-user-select: none; + -ms-touch-action: none; + touch-action: none; + -ms-user-select: none; + -moz-user-select: none; + user-select: none; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +.noUi-target { + position: relative; +} +.noUi-base, +.noUi-connects { + width: 100%; + height: 100%; + position: relative; + z-index: 1; +} +/* Wrapper for all connect elements. + */ +.noUi-connects { + overflow: hidden; + z-index: 0; +} +.noUi-connect, +.noUi-origin { + will-change: transform; + position: absolute; + z-index: 1; + top: 0; + right: 0; + -ms-transform-origin: 0 0; + -webkit-transform-origin: 0 0; + -webkit-transform-style: preserve-3d; + transform-origin: 0 0; + transform-style: flat; +} +.noUi-connect { + height: 100%; + width: 100%; +} +.noUi-origin { + height: 10%; + width: 10%; +} +/* Offset direction + */ +.noUi-txt-dir-rtl.noUi-horizontal .noUi-origin { + left: 0; + right: auto; +} +/* Give origins 0 height/width so they don't interfere with clicking the + * connect elements. + */ +.noUi-vertical .noUi-origin { + width: 0; +} +.noUi-horizontal .noUi-origin { + height: 0; +} +.noUi-handle { + -webkit-backface-visibility: hidden; + backface-visibility: hidden; + position: absolute; +} +.noUi-touch-area { + height: 100%; + width: 100%; +} +.noUi-state-tap .noUi-connect, +.noUi-state-tap .noUi-origin { + -webkit-transition: transform 0.3s; + transition: transform 0.3s; +} +.noUi-state-drag * { + cursor: inherit !important; +} +/* Slider size and handle placement; + */ +.noUi-horizontal { + height: 18px; +} +.noUi-horizontal .noUi-handle { + width: 34px; + height: 28px; + right: -17px; + top: -6px; +} +.noUi-vertical { + width: 18px; +} +.noUi-vertical .noUi-handle { + width: 28px; + height: 34px; + right: -6px; + top: -17px; +} +.noUi-txt-dir-rtl.noUi-horizontal .noUi-handle { + left: -17px; + right: auto; +} +/* Styling; + * Giving the connect element a border radius causes issues with using transform: scale + */ +.noUi-target { + background: #FAFAFA; + border-radius: 4px; + border: 1px solid #D3D3D3; + box-shadow: inset 0 1px 1px #F0F0F0, 0 3px 6px -5px #BBB; +} +.noUi-connects { + border-radius: 3px; +} +.noUi-connect { + background: #3FB8AF; +} +/* Handles and cursors; + */ +.noUi-draggable { + cursor: ew-resize; +} +.noUi-vertical .noUi-draggable { + cursor: ns-resize; +} +.noUi-handle { + border: 1px solid #D9D9D9; + border-radius: 3px; + background: #FFF; + cursor: default; + box-shadow: inset 0 0 1px #FFF, inset 0 1px 7px #EBEBEB, 0 3px 6px -3px #BBB; +} +.noUi-active { + box-shadow: inset 0 0 1px #FFF, inset 0 1px 7px #DDD, 0 3px 6px -3px #BBB; +} +/* Handle stripes; + */ +.noUi-handle:before, +.noUi-handle:after { + content: ""; + display: block; + position: absolute; + height: 14px; + width: 1px; + background: #E8E7E6; + left: 14px; + top: 6px; +} +.noUi-handle:after { + left: 17px; +} +.noUi-vertical .noUi-handle:before, +.noUi-vertical .noUi-handle:after { + width: 14px; + height: 1px; + left: 6px; + top: 14px; +} +.noUi-vertical .noUi-handle:after { + top: 17px; +} +/* Disabled state; + */ +[disabled] .noUi-connect { + background: #B8B8B8; +} +[disabled].noUi-target, +[disabled].noUi-handle, +[disabled] .noUi-handle { + cursor: not-allowed; +} +/* Base; + * + */ +.noUi-pips, +.noUi-pips * { + -moz-box-sizing: border-box; + box-sizing: border-box; +} +.noUi-pips { + position: absolute; + color: #999; +} +/* Values; + * + */ +.noUi-value { + position: absolute; + white-space: nowrap; + text-align: center; +} +.noUi-value-sub { + color: #ccc; + font-size: 10px; +} +/* Markings; + * + */ +.noUi-marker { + position: absolute; + background: #CCC; +} +.noUi-marker-sub { + background: #AAA; +} +.noUi-marker-large { + background: #AAA; +} +/* Horizontal layout; + * + */ +.noUi-pips-horizontal { + padding: 10px 0; + height: 80px; + top: 100%; + left: 0; + width: 100%; +} +.noUi-value-horizontal { + -webkit-transform: translate(-50%, 50%); + transform: translate(-50%, 50%); +} +.noUi-rtl .noUi-value-horizontal { + -webkit-transform: translate(50%, 50%); + transform: translate(50%, 50%); +} +.noUi-marker-horizontal.noUi-marker { + margin-left: -1px; + width: 2px; + height: 5px; +} +.noUi-marker-horizontal.noUi-marker-sub { + height: 10px; +} +.noUi-marker-horizontal.noUi-marker-large { + height: 15px; +} +/* Vertical layout; + * + */ +.noUi-pips-vertical { + padding: 0 10px; + height: 100%; + top: 0; + left: 100%; +} +.noUi-value-vertical { + -webkit-transform: translate(0, -50%); + transform: translate(0, -50%); + padding-left: 25px; +} +.noUi-rtl .noUi-value-vertical { + -webkit-transform: translate(0, 50%); + transform: translate(0, 50%); +} +.noUi-marker-vertical.noUi-marker { + width: 5px; + height: 2px; + margin-top: -1px; +} +.noUi-marker-vertical.noUi-marker-sub { + width: 10px; +} +.noUi-marker-vertical.noUi-marker-large { + width: 15px; +} +.noUi-tooltip { + display: block; + position: absolute; + border: 1px solid #D9D9D9; + border-radius: 3px; + background: #fff; + color: #000; + padding: 5px; + text-align: center; + white-space: nowrap; +} +.noUi-horizontal .noUi-tooltip { + -webkit-transform: translate(-50%, 0); + transform: translate(-50%, 0); + left: 50%; + bottom: 120%; +} +.noUi-vertical .noUi-tooltip { + -webkit-transform: translate(0, -50%); + transform: translate(0, -50%); + top: 50%; + right: 120%; +} +.noUi-horizontal .noUi-origin > .noUi-tooltip { + -webkit-transform: translate(50%, 0); + transform: translate(50%, 0); + left: auto; + bottom: 10px; +} +.noUi-vertical .noUi-origin > .noUi-tooltip { + -webkit-transform: translate(0, -18px); + transform: translate(0, -18px); + top: auto; + right: 28px; +} diff --git a/vcm/sources/nouislider.js b/vcm/sources/nouislider.js new file mode 100644 index 0000000000000000000000000000000000000000..6e743867fb595496327eb09bc2fed0baf1dc5dc1 --- /dev/null +++ b/vcm/sources/nouislider.js @@ -0,0 +1,2668 @@ +/*! nouislider - 14.6.0 - 6/27/2020 */ +(function(factory) { + if (typeof define === "function" && define.amd) { + // AMD. Register as an anonymous module. + define([], factory); + } else if (typeof exports === "object") { + // Node/CommonJS + module.exports = factory(); + } else { + // Browser globals + window.noUiSlider = factory(); + } +})(function() { + "use strict"; + + var VERSION = "14.6.0"; + + //region Helper Methods + + function isValidFormatter(entry) { + return typeof entry === "object" && typeof entry.to === "function" && typeof entry.from === "function"; + } + + function removeElement(el) { + el.parentElement.removeChild(el); + } + + function isSet(value) { + return value !== null && value !== undefined; + } + + // Bindable version + function preventDefault(e) { + e.preventDefault(); + } + + // Removes duplicates from an array. + function unique(array) { + return array.filter(function(a) { + return !this[a] ? (this[a] = true) : false; + }, {}); + } + + // Round a value to the closest 'to'. + function closest(value, to) { + return Math.round(value / to) * to; + } + + // Current position of an element relative to the document. + function offset(elem, orientation) { + var rect = elem.getBoundingClientRect(); + var doc = elem.ownerDocument; + var docElem = doc.documentElement; + var pageOffset = getPageOffset(doc); + + // getBoundingClientRect contains left scroll in Chrome on Android. + // I haven't found a feature detection that proves this. Worst case + // scenario on mis-match: the 'tap' feature on horizontal sliders breaks. + if (/webkit.*Chrome.*Mobile/i.test(navigator.userAgent)) { + pageOffset.x = 0; + } + + return orientation + ? rect.top + pageOffset.y - docElem.clientTop + : rect.left + pageOffset.x - docElem.clientLeft; + } + + // Checks whether a value is numerical. + function isNumeric(a) { + return typeof a === "number" && !isNaN(a) && isFinite(a); + } + + // Sets a class and removes it after [duration] ms. + function addClassFor(element, className, duration) { + if (duration > 0) { + addClass(element, className); + setTimeout(function() { + removeClass(element, className); + }, duration); + } + } + + // Limits a value to 0 - 100 + function limit(a) { + return Math.max(Math.min(a, 100), 0); + } + + // Wraps a variable as an array, if it isn't one yet. + // Note that an input array is returned by reference! + function asArray(a) { + return Array.isArray(a) ? a : [a]; + } + + // Counts decimals + function countDecimals(numStr) { + numStr = String(numStr); + var pieces = numStr.split("."); + return pieces.length > 1 ? pieces[1].length : 0; + } + + // http://youmightnotneedjquery.com/#add_class + function addClass(el, className) { + if (el.classList && !/\s/.test(className)) { + el.classList.add(className); + } else { + el.className += " " + className; + } + } + + // http://youmightnotneedjquery.com/#remove_class + function removeClass(el, className) { + if (el.classList && !/\s/.test(className)) { + el.classList.remove(className); + } else { + el.className = el.className.replace( + new RegExp("(^|\\b)" + className.split(" ").join("|") + "(\\b|$)", "gi"), + " " + ); + } + } + + // https://plainjs.com/javascript/attributes/adding-removing-and-testing-for-classes-9/ + function hasClass(el, className) { + return el.classList + ? el.classList.contains(className) + : new RegExp("\\b" + className + "\\b").test(el.className); + } + + // https://developer.mozilla.org/en-US/docs/Web/API/Window/scrollY#Notes + function getPageOffset(doc) { + var supportPageOffset = window.pageXOffset !== undefined; + var isCSS1Compat = (doc.compatMode || "") === "CSS1Compat"; + var x = supportPageOffset + ? window.pageXOffset + : isCSS1Compat + ? doc.documentElement.scrollLeft + : doc.body.scrollLeft; + var y = supportPageOffset + ? window.pageYOffset + : isCSS1Compat + ? doc.documentElement.scrollTop + : doc.body.scrollTop; + + return { + x: x, + y: y + }; + } + + // we provide a function to compute constants instead + // of accessing window.* as soon as the module needs it + // so that we do not compute anything if not needed + function getActions() { + // Determine the events to bind. IE11 implements pointerEvents without + // a prefix, which breaks compatibility with the IE10 implementation. + return window.navigator.pointerEnabled + ? { + start: "pointerdown", + move: "pointermove", + end: "pointerup" + } + : window.navigator.msPointerEnabled + ? { + start: "MSPointerDown", + move: "MSPointerMove", + end: "MSPointerUp" + } + : { + start: "mousedown touchstart", + move: "mousemove touchmove", + end: "mouseup touchend" + }; + } + + // https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md + // Issue #785 + function getSupportsPassive() { + var supportsPassive = false; + + /* eslint-disable */ + try { + var opts = Object.defineProperty({}, "passive", { + get: function() { + supportsPassive = true; + } + }); + + window.addEventListener("test", null, opts); + } catch (e) {} + /* eslint-enable */ + + return supportsPassive; + } + + function getSupportsTouchActionNone() { + return window.CSS && CSS.supports && CSS.supports("touch-action", "none"); + } + + //endregion + + //region Range Calculation + + // Determine the size of a sub-range in relation to a full range. + function subRangeRatio(pa, pb) { + return 100 / (pb - pa); + } + + // (percentage) How many percent is this value of this range? + function fromPercentage(range, value, startRange) { + return (value * 100) / (range[startRange + 1] - range[startRange]); + } + + // (percentage) Where is this value on this range? + function toPercentage(range, value) { + return fromPercentage(range, range[0] < 0 ? value + Math.abs(range[0]) : value - range[0], 0); + } + + // (value) How much is this percentage on this range? + function isPercentage(range, value) { + return (value * (range[1] - range[0])) / 100 + range[0]; + } + + function getJ(value, arr) { + var j = 1; + + while (value >= arr[j]) { + j += 1; + } + + return j; + } + + // (percentage) Input a value, find where, on a scale of 0-100, it applies. + function toStepping(xVal, xPct, value) { + if (value >= xVal.slice(-1)[0]) { + return 100; + } + + var j = getJ(value, xVal); + var va = xVal[j - 1]; + var vb = xVal[j]; + var pa = xPct[j - 1]; + var pb = xPct[j]; + + return pa + toPercentage([va, vb], value) / subRangeRatio(pa, pb); + } + + // (value) Input a percentage, find where it is on the specified range. + function fromStepping(xVal, xPct, value) { + // There is no range group that fits 100 + if (value >= 100) { + return xVal.slice(-1)[0]; + } + + var j = getJ(value, xPct); + var va = xVal[j - 1]; + var vb = xVal[j]; + var pa = xPct[j - 1]; + var pb = xPct[j]; + + return isPercentage([va, vb], (value - pa) * subRangeRatio(pa, pb)); + } + + // (percentage) Get the step that applies at a certain value. + function getStep(xPct, xSteps, snap, value) { + if (value === 100) { + return value; + } + + var j = getJ(value, xPct); + var a = xPct[j - 1]; + var b = xPct[j]; + + // If 'snap' is set, steps are used as fixed points on the slider. + if (snap) { + // Find the closest position, a or b. + if (value - a > (b - a) / 2) { + return b; + } + + return a; + } + + if (!xSteps[j - 1]) { + return value; + } + + return xPct[j - 1] + closest(value - xPct[j - 1], xSteps[j - 1]); + } + + function handleEntryPoint(index, value, that) { + var percentage; + + // Wrap numerical input in an array. + if (typeof value === "number") { + value = [value]; + } + + // Reject any invalid input, by testing whether value is an array. + if (!Array.isArray(value)) { + throw new Error("noUiSlider (" + VERSION + "): 'range' contains invalid value."); + } + + // Covert min/max syntax to 0 and 100. + if (index === "min") { + percentage = 0; + } else if (index === "max") { + percentage = 100; + } else { + percentage = parseFloat(index); + } + + // Check for correct input. + if (!isNumeric(percentage) || !isNumeric(value[0])) { + throw new Error("noUiSlider (" + VERSION + "): 'range' value isn't numeric."); + } + + // Store values. + that.xPct.push(percentage); + that.xVal.push(value[0]); + + // NaN will evaluate to false too, but to keep + // logging clear, set step explicitly. Make sure + // not to override the 'step' setting with false. + if (!percentage) { + if (!isNaN(value[1])) { + that.xSteps[0] = value[1]; + } + } else { + that.xSteps.push(isNaN(value[1]) ? false : value[1]); + } + + that.xHighestCompleteStep.push(0); + } + + function handleStepPoint(i, n, that) { + // Ignore 'false' stepping. + if (!n) { + return; + } + + // Step over zero-length ranges (#948); + if (that.xVal[i] === that.xVal[i + 1]) { + that.xSteps[i] = that.xHighestCompleteStep[i] = that.xVal[i]; + + return; + } + + // Factor to range ratio + that.xSteps[i] = + fromPercentage([that.xVal[i], that.xVal[i + 1]], n, 0) / subRangeRatio(that.xPct[i], that.xPct[i + 1]); + + var totalSteps = (that.xVal[i + 1] - that.xVal[i]) / that.xNumSteps[i]; + var highestStep = Math.ceil(Number(totalSteps.toFixed(3)) - 1); + var step = that.xVal[i] + that.xNumSteps[i] * highestStep; + + that.xHighestCompleteStep[i] = step; + } + + //endregion + + //region Spectrum + + function Spectrum(entry, snap, singleStep) { + this.xPct = []; + this.xVal = []; + this.xSteps = [singleStep || false]; + this.xNumSteps = [false]; + this.xHighestCompleteStep = []; + + this.snap = snap; + + var index; + var ordered = []; // [0, 'min'], [1, '50%'], [2, 'max'] + + // Map the object keys to an array. + for (index in entry) { + if (entry.hasOwnProperty(index)) { + ordered.push([entry[index], index]); + } + } + + // Sort all entries by value (numeric sort). + if (ordered.length && typeof ordered[0][0] === "object") { + ordered.sort(function(a, b) { + return a[0][0] - b[0][0]; + }); + } else { + ordered.sort(function(a, b) { + return a[0] - b[0]; + }); + } + + // Convert all entries to subranges. + for (index = 0; index < ordered.length; index++) { + handleEntryPoint(ordered[index][1], ordered[index][0], this); + } + + // Store the actual step values. + // xSteps is sorted in the same order as xPct and xVal. + this.xNumSteps = this.xSteps.slice(0); + + // Convert all numeric steps to the percentage of the subrange they represent. + for (index = 0; index < this.xNumSteps.length; index++) { + handleStepPoint(index, this.xNumSteps[index], this); + } + } + + Spectrum.prototype.getDistance = function(value) { + var index; + var distances = []; + + for (index = 0; index < this.xNumSteps.length - 1; index++) { + // last "range" can't contain step size as it is purely an endpoint. + var step = this.xNumSteps[index]; + + if (step && (value / step) % 1 !== 0) { + throw new Error( + "noUiSlider (" + + VERSION + + "): 'limit', 'margin' and 'padding' of " + + this.xPct[index] + + "% range must be divisible by step." + ); + } + + // Calculate percentual distance in current range of limit, margin or padding + distances[index] = fromPercentage(this.xVal, value, index); + } + + return distances; + }; + + // Calculate the percentual distance over the whole scale of ranges. + // direction: 0 = backwards / 1 = forwards + Spectrum.prototype.getAbsoluteDistance = function(value, distances, direction) { + var xPct_index = 0; + + // Calculate range where to start calculation + if (value < this.xPct[this.xPct.length - 1]) { + while (value > this.xPct[xPct_index + 1]) { + xPct_index++; + } + } else if (value === this.xPct[this.xPct.length - 1]) { + xPct_index = this.xPct.length - 2; + } + + // If looking backwards and the value is exactly at a range separator then look one range further + if (!direction && value === this.xPct[xPct_index + 1]) { + xPct_index++; + } + + var start_factor; + var rest_factor = 1; + + var rest_rel_distance = distances[xPct_index]; + + var range_pct = 0; + + var rel_range_distance = 0; + var abs_distance_counter = 0; + var range_counter = 0; + + // Calculate what part of the start range the value is + if (direction) { + start_factor = (value - this.xPct[xPct_index]) / (this.xPct[xPct_index + 1] - this.xPct[xPct_index]); + } else { + start_factor = (this.xPct[xPct_index + 1] - value) / (this.xPct[xPct_index + 1] - this.xPct[xPct_index]); + } + + // Do until the complete distance across ranges is calculated + while (rest_rel_distance > 0) { + // Calculate the percentage of total range + range_pct = this.xPct[xPct_index + 1 + range_counter] - this.xPct[xPct_index + range_counter]; + + // Detect if the margin, padding or limit is larger then the current range and calculate + if (distances[xPct_index + range_counter] * rest_factor + 100 - start_factor * 100 > 100) { + // If larger then take the percentual distance of the whole range + rel_range_distance = range_pct * start_factor; + // Rest factor of relative percentual distance still to be calculated + rest_factor = (rest_rel_distance - 100 * start_factor) / distances[xPct_index + range_counter]; + // Set start factor to 1 as for next range it does not apply. + start_factor = 1; + } else { + // If smaller or equal then take the percentual distance of the calculate percentual part of that range + rel_range_distance = ((distances[xPct_index + range_counter] * range_pct) / 100) * rest_factor; + // No rest left as the rest fits in current range + rest_factor = 0; + } + + if (direction) { + abs_distance_counter = abs_distance_counter - rel_range_distance; + // Limit range to first range when distance becomes outside of minimum range + if (this.xPct.length + range_counter >= 1) { + range_counter--; + } + } else { + abs_distance_counter = abs_distance_counter + rel_range_distance; + // Limit range to last range when distance becomes outside of maximum range + if (this.xPct.length - range_counter >= 1) { + range_counter++; + } + } + + // Rest of relative percentual distance still to be calculated + rest_rel_distance = distances[xPct_index + range_counter] * rest_factor; + } + + return value + abs_distance_counter; + }; + + Spectrum.prototype.toStepping = function(value) { + value = toStepping(this.xVal, this.xPct, value); + + return value; + }; + + Spectrum.prototype.fromStepping = function(value) { + return fromStepping(this.xVal, this.xPct, value); + }; + + Spectrum.prototype.getStep = function(value) { + value = getStep(this.xPct, this.xSteps, this.snap, value); + + return value; + }; + + Spectrum.prototype.getDefaultStep = function(value, isDown, size) { + var j = getJ(value, this.xPct); + + // When at the top or stepping down, look at the previous sub-range + if (value === 100 || (isDown && value === this.xPct[j - 1])) { + j = Math.max(j - 1, 1); + } + + return (this.xVal[j] - this.xVal[j - 1]) / size; + }; + + Spectrum.prototype.getNearbySteps = function(value) { + var j = getJ(value, this.xPct); + + return { + stepBefore: { + startValue: this.xVal[j - 2], + step: this.xNumSteps[j - 2], + highestStep: this.xHighestCompleteStep[j - 2] + }, + thisStep: { + startValue: this.xVal[j - 1], + step: this.xNumSteps[j - 1], + highestStep: this.xHighestCompleteStep[j - 1] + }, + stepAfter: { + startValue: this.xVal[j], + step: this.xNumSteps[j], + highestStep: this.xHighestCompleteStep[j] + } + }; + }; + + Spectrum.prototype.countStepDecimals = function() { + var stepDecimals = this.xNumSteps.map(countDecimals); + return Math.max.apply(null, stepDecimals); + }; + + // Outside testing + Spectrum.prototype.convert = function(value) { + return this.getStep(this.toStepping(value)); + }; + + //endregion + + //region Options + + /* Every input option is tested and parsed. This'll prevent + endless validation in internal methods. These tests are + structured with an item for every option available. An + option can be marked as required by setting the 'r' flag. + The testing function is provided with three arguments: + - The provided value for the option; + - A reference to the options object; + - The name for the option; + + The testing function returns false when an error is detected, + or true when everything is OK. It can also modify the option + object, to make sure all values can be correctly looped elsewhere. */ + + //region Defaults + + var defaultFormatter = { + to: function(value) { + return value !== undefined && value.toFixed(2); + }, + from: Number + }; + + var cssClasses = { + target: "target", + base: "base", + origin: "origin", + handle: "handle", + handleLower: "handle-lower", + handleUpper: "handle-upper", + touchArea: "touch-area", + horizontal: "horizontal", + vertical: "vertical", + background: "background", + connect: "connect", + connects: "connects", + ltr: "ltr", + rtl: "rtl", + textDirectionLtr: "txt-dir-ltr", + textDirectionRtl: "txt-dir-rtl", + draggable: "draggable", + drag: "state-drag", + tap: "state-tap", + active: "active", + tooltip: "tooltip", + pips: "pips", + pipsHorizontal: "pips-horizontal", + pipsVertical: "pips-vertical", + marker: "marker", + markerHorizontal: "marker-horizontal", + markerVertical: "marker-vertical", + markerNormal: "marker-normal", + markerLarge: "marker-large", + markerSub: "marker-sub", + value: "value", + valueHorizontal: "value-horizontal", + valueVertical: "value-vertical", + valueNormal: "value-normal", + valueLarge: "value-large", + valueSub: "value-sub" + }; + + //endregion + + function validateFormat(entry) { + // Any object with a to and from method is supported. + if (isValidFormatter(entry)) { + return true; + } + + throw new Error("noUiSlider (" + VERSION + "): 'format' requires 'to' and 'from' methods."); + } + + function testStep(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'step' is not numeric."); + } + + // The step option can still be used to set stepping + // for linear sliders. Overwritten if set in 'range'. + parsed.singleStep = entry; + } + + function testKeyboardPageMultiplier(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'keyboardPageMultiplier' is not numeric."); + } + + parsed.keyboardPageMultiplier = entry; + } + + function testKeyboardDefaultStep(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'keyboardDefaultStep' is not numeric."); + } + + parsed.keyboardDefaultStep = entry; + } + + function testRange(parsed, entry) { + // Filter incorrect input. + if (typeof entry !== "object" || Array.isArray(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'range' is not an object."); + } + + // Catch missing start or end. + if (entry.min === undefined || entry.max === undefined) { + throw new Error("noUiSlider (" + VERSION + "): Missing 'min' or 'max' in 'range'."); + } + + // Catch equal start or end. + if (entry.min === entry.max) { + throw new Error("noUiSlider (" + VERSION + "): 'range' 'min' and 'max' cannot be equal."); + } + + parsed.spectrum = new Spectrum(entry, parsed.snap, parsed.singleStep); + } + + function testStart(parsed, entry) { + entry = asArray(entry); + + // Validate input. Values aren't tested, as the public .val method + // will always provide a valid location. + if (!Array.isArray(entry) || !entry.length) { + throw new Error("noUiSlider (" + VERSION + "): 'start' option is incorrect."); + } + + // Store the number of handles. + parsed.handles = entry.length; + + // When the slider is initialized, the .val method will + // be called with the start options. + parsed.start = entry; + } + + function testSnap(parsed, entry) { + // Enforce 100% stepping within subranges. + parsed.snap = entry; + + if (typeof entry !== "boolean") { + throw new Error("noUiSlider (" + VERSION + "): 'snap' option must be a boolean."); + } + } + + function testAnimate(parsed, entry) { + // Enforce 100% stepping within subranges. + parsed.animate = entry; + + if (typeof entry !== "boolean") { + throw new Error("noUiSlider (" + VERSION + "): 'animate' option must be a boolean."); + } + } + + function testAnimationDuration(parsed, entry) { + parsed.animationDuration = entry; + + if (typeof entry !== "number") { + throw new Error("noUiSlider (" + VERSION + "): 'animationDuration' option must be a number."); + } + } + + function testConnect(parsed, entry) { + var connect = [false]; + var i; + + // Map legacy options + if (entry === "lower") { + entry = [true, false]; + } else if (entry === "upper") { + entry = [false, true]; + } + + // Handle boolean options + if (entry === true || entry === false) { + for (i = 1; i < parsed.handles; i++) { + connect.push(entry); + } + + connect.push(false); + } + + // Reject invalid input + else if (!Array.isArray(entry) || !entry.length || entry.length !== parsed.handles + 1) { + throw new Error("noUiSlider (" + VERSION + "): 'connect' option doesn't match handle count."); + } else { + connect = entry; + } + + parsed.connect = connect; + } + + function testOrientation(parsed, entry) { + // Set orientation to an a numerical value for easy + // array selection. + switch (entry) { + case "horizontal": + parsed.ort = 0; + break; + case "vertical": + parsed.ort = 1; + break; + default: + throw new Error("noUiSlider (" + VERSION + "): 'orientation' option is invalid."); + } + } + + function testMargin(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'margin' option must be numeric."); + } + + // Issue #582 + if (entry === 0) { + return; + } + + parsed.margin = parsed.spectrum.getDistance(entry); + } + + function testLimit(parsed, entry) { + if (!isNumeric(entry)) { + throw new Error("noUiSlider (" + VERSION + "): 'limit' option must be numeric."); + } + + parsed.limit = parsed.spectrum.getDistance(entry); + + if (!parsed.limit || parsed.handles < 2) { + throw new Error( + "noUiSlider (" + + VERSION + + "): 'limit' option is only supported on linear sliders with 2 or more handles." + ); + } + } + + function testPadding(parsed, entry) { + var index; + + if (!isNumeric(entry) && !Array.isArray(entry)) { + throw new Error( + "noUiSlider (" + VERSION + "): 'padding' option must be numeric or array of exactly 2 numbers." + ); + } + + if (Array.isArray(entry) && !(entry.length === 2 || isNumeric(entry[0]) || isNumeric(entry[1]))) { + throw new Error( + "noUiSlider (" + VERSION + "): 'padding' option must be numeric or array of exactly 2 numbers." + ); + } + + if (entry === 0) { + return; + } + + if (!Array.isArray(entry)) { + entry = [entry, entry]; + } + + // 'getDistance' returns false for invalid values. + parsed.padding = [parsed.spectrum.getDistance(entry[0]), parsed.spectrum.getDistance(entry[1])]; + + for (index = 0; index < parsed.spectrum.xNumSteps.length - 1; index++) { + // last "range" can't contain step size as it is purely an endpoint. + if (parsed.padding[0][index] < 0 || parsed.padding[1][index] < 0) { + throw new Error("noUiSlider (" + VERSION + "): 'padding' option must be a positive number(s)."); + } + } + + var totalPadding = entry[0] + entry[1]; + var firstValue = parsed.spectrum.xVal[0]; + var lastValue = parsed.spectrum.xVal[parsed.spectrum.xVal.length - 1]; + + if (totalPadding / (lastValue - firstValue) > 1) { + throw new Error("noUiSlider (" + VERSION + "): 'padding' option must not exceed 100% of the range."); + } + } + + function testDirection(parsed, entry) { + // Set direction as a numerical value for easy parsing. + // Invert connection for RTL sliders, so that the proper + // handles get the connect/background classes. + switch (entry) { + case "ltr": + parsed.dir = 0; + break; + case "rtl": + parsed.dir = 1; + break; + default: + throw new Error("noUiSlider (" + VERSION + "): 'direction' option was not recognized."); + } + } + + function testBehaviour(parsed, entry) { + // Make sure the input is a string. + if (typeof entry !== "string") { + throw new Error("noUiSlider (" + VERSION + "): 'behaviour' must be a string containing options."); + } + + // Check if the string contains any keywords. + // None are required. + var tap = entry.indexOf("tap") >= 0; + var drag = entry.indexOf("drag") >= 0; + var fixed = entry.indexOf("fixed") >= 0; + var snap = entry.indexOf("snap") >= 0; + var hover = entry.indexOf("hover") >= 0; + var unconstrained = entry.indexOf("unconstrained") >= 0; + + if (fixed) { + if (parsed.handles !== 2) { + throw new Error("noUiSlider (" + VERSION + "): 'fixed' behaviour must be used with 2 handles"); + } + + // Use margin to enforce fixed state + testMargin(parsed, parsed.start[1] - parsed.start[0]); + } + + if (unconstrained && (parsed.margin || parsed.limit)) { + throw new Error( + "noUiSlider (" + VERSION + "): 'unconstrained' behaviour cannot be used with margin or limit" + ); + } + + parsed.events = { + tap: tap || snap, + drag: drag, + fixed: fixed, + snap: snap, + hover: hover, + unconstrained: unconstrained + }; + } + + function testTooltips(parsed, entry) { + if (entry === false) { + return; + } + + if (entry === true) { + parsed.tooltips = []; + + for (var i = 0; i < parsed.handles; i++) { + parsed.tooltips.push(true); + } + } else { + parsed.tooltips = asArray(entry); + + if (parsed.tooltips.length !== parsed.handles) { + throw new Error("noUiSlider (" + VERSION + "): must pass a formatter for all handles."); + } + + parsed.tooltips.forEach(function(formatter) { + if ( + typeof formatter !== "boolean" && + (typeof formatter !== "object" || typeof formatter.to !== "function") + ) { + throw new Error("noUiSlider (" + VERSION + "): 'tooltips' must be passed a formatter or 'false'."); + } + }); + } + } + + function testAriaFormat(parsed, entry) { + parsed.ariaFormat = entry; + validateFormat(entry); + } + + function testFormat(parsed, entry) { + parsed.format = entry; + validateFormat(entry); + } + + function testKeyboardSupport(parsed, entry) { + parsed.keyboardSupport = entry; + + if (typeof entry !== "boolean") { + throw new Error("noUiSlider (" + VERSION + "): 'keyboardSupport' option must be a boolean."); + } + } + + function testDocumentElement(parsed, entry) { + // This is an advanced option. Passed values are used without validation. + parsed.documentElement = entry; + } + + function testCssPrefix(parsed, entry) { + if (typeof entry !== "string" && entry !== false) { + throw new Error("noUiSlider (" + VERSION + "): 'cssPrefix' must be a string or `false`."); + } + + parsed.cssPrefix = entry; + } + + function testCssClasses(parsed, entry) { + if (typeof entry !== "object") { + throw new Error("noUiSlider (" + VERSION + "): 'cssClasses' must be an object."); + } + + if (typeof parsed.cssPrefix === "string") { + parsed.cssClasses = {}; + + for (var key in entry) { + if (!entry.hasOwnProperty(key)) { + continue; + } + + parsed.cssClasses[key] = parsed.cssPrefix + entry[key]; + } + } else { + parsed.cssClasses = entry; + } + } + + // Test all developer settings and parse to assumption-safe values. + function testOptions(options) { + // To prove a fix for #537, freeze options here. + // If the object is modified, an error will be thrown. + // Object.freeze(options); + + var parsed = { + margin: 0, + limit: 0, + padding: 0, + animate: true, + animationDuration: 300, + ariaFormat: defaultFormatter, + format: defaultFormatter + }; + + // Tests are executed in the order they are presented here. + var tests = { + step: { r: false, t: testStep }, + keyboardPageMultiplier: { r: false, t: testKeyboardPageMultiplier }, + keyboardDefaultStep: { r: false, t: testKeyboardDefaultStep }, + start: { r: true, t: testStart }, + connect: { r: true, t: testConnect }, + direction: { r: true, t: testDirection }, + snap: { r: false, t: testSnap }, + animate: { r: false, t: testAnimate }, + animationDuration: { r: false, t: testAnimationDuration }, + range: { r: true, t: testRange }, + orientation: { r: false, t: testOrientation }, + margin: { r: false, t: testMargin }, + limit: { r: false, t: testLimit }, + padding: { r: false, t: testPadding }, + behaviour: { r: true, t: testBehaviour }, + ariaFormat: { r: false, t: testAriaFormat }, + format: { r: false, t: testFormat }, + tooltips: { r: false, t: testTooltips }, + keyboardSupport: { r: true, t: testKeyboardSupport }, + documentElement: { r: false, t: testDocumentElement }, + cssPrefix: { r: true, t: testCssPrefix }, + cssClasses: { r: true, t: testCssClasses } + }; + + var defaults = { + connect: false, + direction: "ltr", + behaviour: "tap", + orientation: "horizontal", + keyboardSupport: true, + cssPrefix: "noUi-", + cssClasses: cssClasses, + keyboardPageMultiplier: 5, + keyboardDefaultStep: 10 + }; + + // AriaFormat defaults to regular format, if any. + if (options.format && !options.ariaFormat) { + options.ariaFormat = options.format; + } + + // Run all options through a testing mechanism to ensure correct + // input. It should be noted that options might get modified to + // be handled properly. E.g. wrapping integers in arrays. + Object.keys(tests).forEach(function(name) { + // If the option isn't set, but it is required, throw an error. + if (!isSet(options[name]) && defaults[name] === undefined) { + if (tests[name].r) { + throw new Error("noUiSlider (" + VERSION + "): '" + name + "' is required."); + } + + return true; + } + + tests[name].t(parsed, !isSet(options[name]) ? defaults[name] : options[name]); + }); + + // Forward pips options + parsed.pips = options.pips; + + // All recent browsers accept unprefixed transform. + // We need -ms- for IE9 and -webkit- for older Android; + // Assume use of -webkit- if unprefixed and -ms- are not supported. + // https://caniuse.com/#feat=transforms2d + var d = document.createElement("div"); + var msPrefix = d.style.msTransform !== undefined; + var noPrefix = d.style.transform !== undefined; + + parsed.transformRule = noPrefix ? "transform" : msPrefix ? "msTransform" : "webkitTransform"; + + // Pips don't move, so we can place them using left/top. + var styles = [["left", "top"], ["right", "bottom"]]; + + parsed.style = styles[parsed.dir][parsed.ort]; + + return parsed; + } + + //endregion + + function scope(target, options, originalOptions) { + var actions = getActions(); + var supportsTouchActionNone = getSupportsTouchActionNone(); + var supportsPassive = supportsTouchActionNone && getSupportsPassive(); + + // All variables local to 'scope' are prefixed with 'scope_' + + // Slider DOM Nodes + var scope_Target = target; + var scope_Base; + var scope_Handles; + var scope_Connects; + var scope_Pips; + var scope_Tooltips; + + // Slider state values + var scope_Spectrum = options.spectrum; + var scope_Values = []; + var scope_Locations = []; + var scope_HandleNumbers = []; + var scope_ActiveHandlesCount = 0; + var scope_Events = {}; + + // Exposed API + var scope_Self; + + // Document Nodes + var scope_Document = target.ownerDocument; + var scope_DocumentElement = options.documentElement || scope_Document.documentElement; + var scope_Body = scope_Document.body; + + // Pips constants + var PIPS_NONE = -1; + var PIPS_NO_VALUE = 0; + var PIPS_LARGE_VALUE = 1; + var PIPS_SMALL_VALUE = 2; + + // For horizontal sliders in standard ltr documents, + // make .noUi-origin overflow to the left so the document doesn't scroll. + var scope_DirOffset = scope_Document.dir === "rtl" || options.ort === 1 ? 0 : 100; + + // Creates a node, adds it to target, returns the new node. + function addNodeTo(addTarget, className) { + var div = scope_Document.createElement("div"); + + if (className) { + addClass(div, className); + } + + addTarget.appendChild(div); + + return div; + } + + // Append a origin to the base + function addOrigin(base, handleNumber) { + var origin = addNodeTo(base, options.cssClasses.origin); + var handle = addNodeTo(origin, options.cssClasses.handle); + + addNodeTo(handle, options.cssClasses.touchArea); + + handle.setAttribute("data-handle", handleNumber); + + if (options.keyboardSupport) { + // https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex + // 0 = focusable and reachable + handle.setAttribute("tabindex", "0"); + handle.addEventListener("keydown", function(event) { + return eventKeydown(event, handleNumber); + }); + } + + handle.setAttribute("role", "slider"); + handle.setAttribute("aria-orientation", options.ort ? "vertical" : "horizontal"); + + if (handleNumber === 0) { + addClass(handle, options.cssClasses.handleLower); + } else if (handleNumber === options.handles - 1) { + addClass(handle, options.cssClasses.handleUpper); + } + + return origin; + } + + // Insert nodes for connect elements + function addConnect(base, add) { + if (!add) { + return false; + } + + return addNodeTo(base, options.cssClasses.connect); + } + + // Add handles to the slider base. + function addElements(connectOptions, base) { + var connectBase = addNodeTo(base, options.cssClasses.connects); + + scope_Handles = []; + scope_Connects = []; + + scope_Connects.push(addConnect(connectBase, connectOptions[0])); + + // [::::O====O====O====] + // connectOptions = [0, 1, 1, 1] + + for (var i = 0; i < options.handles; i++) { + // Keep a list of all added handles. + scope_Handles.push(addOrigin(base, i)); + scope_HandleNumbers[i] = i; + scope_Connects.push(addConnect(connectBase, connectOptions[i + 1])); + } + } + + // Initialize a single slider. + function addSlider(addTarget) { + // Apply classes and data to the target. + addClass(addTarget, options.cssClasses.target); + + if (options.dir === 0) { + addClass(addTarget, options.cssClasses.ltr); + } else { + addClass(addTarget, options.cssClasses.rtl); + } + + if (options.ort === 0) { + addClass(addTarget, options.cssClasses.horizontal); + } else { + addClass(addTarget, options.cssClasses.vertical); + } + + var textDirection = getComputedStyle(addTarget).direction; + + if (textDirection === "rtl") { + addClass(addTarget, options.cssClasses.textDirectionRtl); + } else { + addClass(addTarget, options.cssClasses.textDirectionLtr); + } + + return addNodeTo(addTarget, options.cssClasses.base); + } + + function addTooltip(handle, handleNumber) { + if (!options.tooltips[handleNumber]) { + return false; + } + + return addNodeTo(handle.firstChild, options.cssClasses.tooltip); + } + + function isSliderDisabled() { + return scope_Target.hasAttribute("disabled"); + } + + // Disable the slider dragging if any handle is disabled + function isHandleDisabled(handleNumber) { + var handleOrigin = scope_Handles[handleNumber]; + return handleOrigin.hasAttribute("disabled"); + } + + function removeTooltips() { + if (scope_Tooltips) { + removeEvent("update.tooltips"); + scope_Tooltips.forEach(function(tooltip) { + if (tooltip) { + removeElement(tooltip); + } + }); + scope_Tooltips = null; + } + } + + // The tooltips option is a shorthand for using the 'update' event. + function tooltips() { + removeTooltips(); + + // Tooltips are added with options.tooltips in original order. + scope_Tooltips = scope_Handles.map(addTooltip); + + bindEvent("update.tooltips", function(values, handleNumber, unencoded) { + if (!scope_Tooltips[handleNumber]) { + return; + } + + var formattedValue = values[handleNumber]; + + if (options.tooltips[handleNumber] !== true) { + formattedValue = options.tooltips[handleNumber].to(unencoded[handleNumber]); + } + + scope_Tooltips[handleNumber].innerHTML = formattedValue; + }); + } + + function aria() { + bindEvent("update", function(values, handleNumber, unencoded, tap, positions) { + // Update Aria Values for all handles, as a change in one changes min and max values for the next. + scope_HandleNumbers.forEach(function(index) { + var handle = scope_Handles[index]; + + var min = checkHandlePosition(scope_Locations, index, 0, true, true, true); + var max = checkHandlePosition(scope_Locations, index, 100, true, true, true); + + var now = positions[index]; + + // Formatted value for display + var text = options.ariaFormat.to(unencoded[index]); + + // Map to slider range values + min = scope_Spectrum.fromStepping(min).toFixed(1); + max = scope_Spectrum.fromStepping(max).toFixed(1); + now = scope_Spectrum.fromStepping(now).toFixed(1); + + handle.children[0].setAttribute("aria-valuemin", min); + handle.children[0].setAttribute("aria-valuemax", max); + handle.children[0].setAttribute("aria-valuenow", now); + handle.children[0].setAttribute("aria-valuetext", text); + }); + }); + } + + function getGroup(mode, values, stepped) { + // Use the range. + if (mode === "range" || mode === "steps") { + return scope_Spectrum.xVal; + } + + if (mode === "count") { + if (values < 2) { + throw new Error("noUiSlider (" + VERSION + "): 'values' (>= 2) required for mode 'count'."); + } + + // Divide 0 - 100 in 'count' parts. + var interval = values - 1; + var spread = 100 / interval; + + values = []; + + // List these parts and have them handled as 'positions'. + while (interval--) { + values[interval] = interval * spread; + } + + values.push(100); + + mode = "positions"; + } + + if (mode === "positions") { + // Map all percentages to on-range values. + return values.map(function(value) { + return scope_Spectrum.fromStepping(stepped ? scope_Spectrum.getStep(value) : value); + }); + } + + if (mode === "values") { + // If the value must be stepped, it needs to be converted to a percentage first. + if (stepped) { + return values.map(function(value) { + // Convert to percentage, apply step, return to value. + return scope_Spectrum.fromStepping(scope_Spectrum.getStep(scope_Spectrum.toStepping(value))); + }); + } + + // Otherwise, we can simply use the values. + return values; + } + } + + function generateSpread(density, mode, group) { + function safeIncrement(value, increment) { + // Avoid floating point variance by dropping the smallest decimal places. + return (value + increment).toFixed(7) / 1; + } + + var indexes = {}; + var firstInRange = scope_Spectrum.xVal[0]; + var lastInRange = scope_Spectrum.xVal[scope_Spectrum.xVal.length - 1]; + var ignoreFirst = false; + var ignoreLast = false; + var prevPct = 0; + + // Create a copy of the group, sort it and filter away all duplicates. + group = unique( + group.slice().sort(function(a, b) { + return a - b; + }) + ); + + // Make sure the range starts with the first element. + if (group[0] !== firstInRange) { + group.unshift(firstInRange); + ignoreFirst = true; + } + + // Likewise for the last one. + if (group[group.length - 1] !== lastInRange) { + group.push(lastInRange); + ignoreLast = true; + } + + group.forEach(function(current, index) { + // Get the current step and the lower + upper positions. + var step; + var i; + var q; + var low = current; + var high = group[index + 1]; + var newPct; + var pctDifference; + var pctPos; + var type; + var steps; + var realSteps; + var stepSize; + var isSteps = mode === "steps"; + + // When using 'steps' mode, use the provided steps. + // Otherwise, we'll step on to the next subrange. + if (isSteps) { + step = scope_Spectrum.xNumSteps[index]; + } + + // Default to a 'full' step. + if (!step) { + step = high - low; + } + + // Low can be 0, so test for false. If high is undefined, + // we are at the last subrange. Index 0 is already handled. + if (low === false || high === undefined) { + return; + } + + // Make sure step isn't 0, which would cause an infinite loop (#654) + step = Math.max(step, 0.0000001); + + // Find all steps in the subrange. + for (i = low; i <= high; i = safeIncrement(i, step)) { + // Get the percentage value for the current step, + // calculate the size for the subrange. + newPct = scope_Spectrum.toStepping(i); + pctDifference = newPct - prevPct; + + steps = pctDifference / density; + realSteps = Math.round(steps); + + // This ratio represents the amount of percentage-space a point indicates. + // For a density 1 the points/percentage = 1. For density 2, that percentage needs to be re-divided. + // Round the percentage offset to an even number, then divide by two + // to spread the offset on both sides of the range. + stepSize = pctDifference / realSteps; + + // Divide all points evenly, adding the correct number to this subrange. + // Run up to <= so that 100% gets a point, event if ignoreLast is set. + for (q = 1; q <= realSteps; q += 1) { + // The ratio between the rounded value and the actual size might be ~1% off. + // Correct the percentage offset by the number of points + // per subrange. density = 1 will result in 100 points on the + // full range, 2 for 50, 4 for 25, etc. + pctPos = prevPct + q * stepSize; + indexes[pctPos.toFixed(5)] = [scope_Spectrum.fromStepping(pctPos), 0]; + } + + // Determine the point type. + type = group.indexOf(i) > -1 ? PIPS_LARGE_VALUE : isSteps ? PIPS_SMALL_VALUE : PIPS_NO_VALUE; + + // Enforce the 'ignoreFirst' option by overwriting the type for 0. + if (!index && ignoreFirst && i !== high) { + type = 0; + } + + if (!(i === high && ignoreLast)) { + // Mark the 'type' of this point. 0 = plain, 1 = real value, 2 = step value. + indexes[newPct.toFixed(5)] = [i, type]; + } + + // Update the percentage count. + prevPct = newPct; + } + }); + + return indexes; + } + + function addMarking(spread, filterFunc, formatter) { + var element = scope_Document.createElement("div"); + + var valueSizeClasses = []; + valueSizeClasses[PIPS_NO_VALUE] = options.cssClasses.valueNormal; + valueSizeClasses[PIPS_LARGE_VALUE] = options.cssClasses.valueLarge; + valueSizeClasses[PIPS_SMALL_VALUE] = options.cssClasses.valueSub; + + var markerSizeClasses = []; + markerSizeClasses[PIPS_NO_VALUE] = options.cssClasses.markerNormal; + markerSizeClasses[PIPS_LARGE_VALUE] = options.cssClasses.markerLarge; + markerSizeClasses[PIPS_SMALL_VALUE] = options.cssClasses.markerSub; + + var valueOrientationClasses = [options.cssClasses.valueHorizontal, options.cssClasses.valueVertical]; + var markerOrientationClasses = [options.cssClasses.markerHorizontal, options.cssClasses.markerVertical]; + + addClass(element, options.cssClasses.pips); + addClass(element, options.ort === 0 ? options.cssClasses.pipsHorizontal : options.cssClasses.pipsVertical); + + function getClasses(type, source) { + var a = source === options.cssClasses.value; + var orientationClasses = a ? valueOrientationClasses : markerOrientationClasses; + var sizeClasses = a ? valueSizeClasses : markerSizeClasses; + + return source + " " + orientationClasses[options.ort] + " " + sizeClasses[type]; + } + + function addSpread(offset, value, type) { + // Apply the filter function, if it is set. + type = filterFunc ? filterFunc(value, type) : type; + + if (type === PIPS_NONE) { + return; + } + + // Add a marker for every point + var node = addNodeTo(element, false); + node.className = getClasses(type, options.cssClasses.marker); + node.style[options.style] = offset + "%"; + + // Values are only appended for points marked '1' or '2'. + if (type > PIPS_NO_VALUE) { + node = addNodeTo(element, false); + node.className = getClasses(type, options.cssClasses.value); + node.setAttribute("data-value", value); + node.style[options.style] = offset + "%"; + node.innerHTML = formatter.to(value); + } + } + + // Append all points. + Object.keys(spread).forEach(function(offset) { + addSpread(offset, spread[offset][0], spread[offset][1]); + }); + + return element; + } + + function removePips() { + if (scope_Pips) { + removeElement(scope_Pips); + scope_Pips = null; + } + } + + function pips(grid) { + // Fix #669 + removePips(); + + var mode = grid.mode; + var density = grid.density || 1; + var filter = grid.filter || false; + var values = grid.values || false; + var stepped = grid.stepped || false; + var group = getGroup(mode, values, stepped); + var spread = generateSpread(density, mode, group); + var format = grid.format || { + to: Math.round + }; + + scope_Pips = scope_Target.appendChild(addMarking(spread, filter, format)); + + return scope_Pips; + } + + // Shorthand for base dimensions. + function baseSize() { + var rect = scope_Base.getBoundingClientRect(); + var alt = "offset" + ["Width", "Height"][options.ort]; + return options.ort === 0 ? rect.width || scope_Base[alt] : rect.height || scope_Base[alt]; + } + + // Handler for attaching events trough a proxy. + function attachEvent(events, element, callback, data) { + // This function can be used to 'filter' events to the slider. + // element is a node, not a nodeList + + var method = function(e) { + e = fixEvent(e, data.pageOffset, data.target || element); + + // fixEvent returns false if this event has a different target + // when handling (multi-) touch events; + if (!e) { + return false; + } + + // doNotReject is passed by all end events to make sure released touches + // are not rejected, leaving the slider "stuck" to the cursor; + if (isSliderDisabled() && !data.doNotReject) { + return false; + } + + // Stop if an active 'tap' transition is taking place. + if (hasClass(scope_Target, options.cssClasses.tap) && !data.doNotReject) { + return false; + } + + // Ignore right or middle clicks on start #454 + if (events === actions.start && e.buttons !== undefined && e.buttons > 1) { + return false; + } + + // Ignore right or middle clicks on start #454 + if (data.hover && e.buttons) { + return false; + } + + // 'supportsPassive' is only true if a browser also supports touch-action: none in CSS. + // iOS safari does not, so it doesn't get to benefit from passive scrolling. iOS does support + // touch-action: manipulation, but that allows panning, which breaks + // sliders after zooming/on non-responsive pages. + // See: https://bugs.webkit.org/show_bug.cgi?id=133112 + if (!supportsPassive) { + e.preventDefault(); + } + + e.calcPoint = e.points[options.ort]; + + // Call the event handler with the event [ and additional data ]. + callback(e, data); + }; + + var methods = []; + + // Bind a closure on the target for every event type. + events.split(" ").forEach(function(eventName) { + element.addEventListener(eventName, method, supportsPassive ? { passive: true } : false); + methods.push([eventName, method]); + }); + + return methods; + } + + // Provide a clean event with standardized offset values. + function fixEvent(e, pageOffset, eventTarget) { + // Filter the event to register the type, which can be + // touch, mouse or pointer. Offset changes need to be + // made on an event specific basis. + var touch = e.type.indexOf("touch") === 0; + var mouse = e.type.indexOf("mouse") === 0; + var pointer = e.type.indexOf("pointer") === 0; + + var x; + var y; + + // IE10 implemented pointer events with a prefix; + if (e.type.indexOf("MSPointer") === 0) { + pointer = true; + } + + // The only thing one handle should be concerned about is the touches that originated on top of it. + if (touch) { + // Returns true if a touch originated on the target. + var isTouchOnTarget = function(checkTouch) { + return ( + checkTouch.target === eventTarget || + eventTarget.contains(checkTouch.target) || + (checkTouch.target.shadowRoot && checkTouch.target.shadowRoot.contains(eventTarget)) + ); + }; + + // In the case of touchstart events, we need to make sure there is still no more than one + // touch on the target so we look amongst all touches. + if (e.type === "touchstart") { + var targetTouches = Array.prototype.filter.call(e.touches, isTouchOnTarget); + + // Do not support more than one touch per handle. + if (targetTouches.length > 1) { + return false; + } + + x = targetTouches[0].pageX; + y = targetTouches[0].pageY; + } else { + // In the other cases, find on changedTouches is enough. + var targetTouch = Array.prototype.find.call(e.changedTouches, isTouchOnTarget); + + // Cancel if the target touch has not moved. + if (!targetTouch) { + return false; + } + + x = targetTouch.pageX; + y = targetTouch.pageY; + } + } + + pageOffset = pageOffset || getPageOffset(scope_Document); + + if (mouse || pointer) { + x = e.clientX + pageOffset.x; + y = e.clientY + pageOffset.y; + } + + e.pageOffset = pageOffset; + e.points = [x, y]; + e.cursor = mouse || pointer; // Fix #435 + + return e; + } + + // Translate a coordinate in the document to a percentage on the slider + function calcPointToPercentage(calcPoint) { + var location = calcPoint - offset(scope_Base, options.ort); + var proposal = (location * 100) / baseSize(); + + // Clamp proposal between 0% and 100% + // Out-of-bound coordinates may occur when .noUi-base pseudo-elements + // are used (e.g. contained handles feature) + proposal = limit(proposal); + + return options.dir ? 100 - proposal : proposal; + } + + // Find handle closest to a certain percentage on the slider + function getClosestHandle(clickedPosition) { + var smallestDifference = 100; + var handleNumber = false; + + scope_Handles.forEach(function(handle, index) { + // Disabled handles are ignored + if (isHandleDisabled(index)) { + return; + } + + var handlePosition = scope_Locations[index]; + var differenceWithThisHandle = Math.abs(handlePosition - clickedPosition); + + // Initial state + var clickAtEdge = differenceWithThisHandle === 100 && smallestDifference === 100; + + // Difference with this handle is smaller than the previously checked handle + var isCloser = differenceWithThisHandle < smallestDifference; + var isCloserAfter = differenceWithThisHandle <= smallestDifference && clickedPosition > handlePosition; + + if (isCloser || isCloserAfter || clickAtEdge) { + handleNumber = index; + smallestDifference = differenceWithThisHandle; + } + }); + + return handleNumber; + } + + // Fire 'end' when a mouse or pen leaves the document. + function documentLeave(event, data) { + if (event.type === "mouseout" && event.target.nodeName === "HTML" && event.relatedTarget === null) { + eventEnd(event, data); + } + } + + // Handle movement on document for handle and range drag. + function eventMove(event, data) { + // Fix #498 + // Check value of .buttons in 'start' to work around a bug in IE10 mobile (data.buttonsProperty). + // https://connect.microsoft.com/IE/feedback/details/927005/mobile-ie10-windows-phone-buttons-property-of-pointermove-event-always-zero + // IE9 has .buttons and .which zero on mousemove. + // Firefox breaks the spec MDN defines. + if (navigator.appVersion.indexOf("MSIE 9") === -1 && event.buttons === 0 && data.buttonsProperty !== 0) { + return eventEnd(event, data); + } + + // Check if we are moving up or down + var movement = (options.dir ? -1 : 1) * (event.calcPoint - data.startCalcPoint); + + // Convert the movement into a percentage of the slider width/height + var proposal = (movement * 100) / data.baseSize; + + moveHandles(movement > 0, proposal, data.locations, data.handleNumbers); + } + + // Unbind move events on document, call callbacks. + function eventEnd(event, data) { + // The handle is no longer active, so remove the class. + if (data.handle) { + removeClass(data.handle, options.cssClasses.active); + scope_ActiveHandlesCount -= 1; + } + + // Unbind the move and end events, which are added on 'start'. + data.listeners.forEach(function(c) { + scope_DocumentElement.removeEventListener(c[0], c[1]); + }); + + if (scope_ActiveHandlesCount === 0) { + // Remove dragging class. + removeClass(scope_Target, options.cssClasses.drag); + setZindex(); + + // Remove cursor styles and text-selection events bound to the body. + if (event.cursor) { + scope_Body.style.cursor = ""; + scope_Body.removeEventListener("selectstart", preventDefault); + } + } + + data.handleNumbers.forEach(function(handleNumber) { + fireEvent("change", handleNumber); + fireEvent("set", handleNumber); + fireEvent("end", handleNumber); + }); + } + + // Bind move events on document. + function eventStart(event, data) { + // Ignore event if any handle is disabled + if (data.handleNumbers.some(isHandleDisabled)) { + return false; + } + + var handle; + + if (data.handleNumbers.length === 1) { + var handleOrigin = scope_Handles[data.handleNumbers[0]]; + + handle = handleOrigin.children[0]; + scope_ActiveHandlesCount += 1; + + // Mark the handle as 'active' so it can be styled. + addClass(handle, options.cssClasses.active); + } + + // A drag should never propagate up to the 'tap' event. + event.stopPropagation(); + + // Record the event listeners. + var listeners = []; + + // Attach the move and end events. + var moveEvent = attachEvent(actions.move, scope_DocumentElement, eventMove, { + // The event target has changed so we need to propagate the original one so that we keep + // relying on it to extract target touches. + target: event.target, + handle: handle, + listeners: listeners, + startCalcPoint: event.calcPoint, + baseSize: baseSize(), + pageOffset: event.pageOffset, + handleNumbers: data.handleNumbers, + buttonsProperty: event.buttons, + locations: scope_Locations.slice() + }); + + var endEvent = attachEvent(actions.end, scope_DocumentElement, eventEnd, { + target: event.target, + handle: handle, + listeners: listeners, + doNotReject: true, + handleNumbers: data.handleNumbers + }); + + var outEvent = attachEvent("mouseout", scope_DocumentElement, documentLeave, { + target: event.target, + handle: handle, + listeners: listeners, + doNotReject: true, + handleNumbers: data.handleNumbers + }); + + // We want to make sure we pushed the listeners in the listener list rather than creating + // a new one as it has already been passed to the event handlers. + listeners.push.apply(listeners, moveEvent.concat(endEvent, outEvent)); + + // Text selection isn't an issue on touch devices, + // so adding cursor styles can be skipped. + if (event.cursor) { + // Prevent the 'I' cursor and extend the range-drag cursor. + scope_Body.style.cursor = getComputedStyle(event.target).cursor; + + // Mark the target with a dragging state. + if (scope_Handles.length > 1) { + addClass(scope_Target, options.cssClasses.drag); + } + + // Prevent text selection when dragging the handles. + // In noUiSlider <= 9.2.0, this was handled by calling preventDefault on mouse/touch start/move, + // which is scroll blocking. The selectstart event is supported by FireFox starting from version 52, + // meaning the only holdout is iOS Safari. This doesn't matter: text selection isn't triggered there. + // The 'cursor' flag is false. + // See: http://caniuse.com/#search=selectstart + scope_Body.addEventListener("selectstart", preventDefault, false); + } + + data.handleNumbers.forEach(function(handleNumber) { + fireEvent("start", handleNumber); + }); + } + + // Move closest handle to tapped location. + function eventTap(event) { + // Erroneous events seem to be passed in occasionally on iOS/iPadOS after user finishes interacting with + // the slider. They appear to be of type MouseEvent, yet they don't have usual properties set. Ignore tap + // events that have no touches or buttons associated with them. + if (!event.buttons && !event.touches) { + return false; + } + + // The tap event shouldn't propagate up + event.stopPropagation(); + + var proposal = calcPointToPercentage(event.calcPoint); + var handleNumber = getClosestHandle(proposal); + + // Tackle the case that all handles are 'disabled'. + if (handleNumber === false) { + return false; + } + + // Flag the slider as it is now in a transitional state. + // Transition takes a configurable amount of ms (default 300). Re-enable the slider after that. + if (!options.events.snap) { + addClassFor(scope_Target, options.cssClasses.tap, options.animationDuration); + } + + setHandle(handleNumber, proposal, true, true); + + setZindex(); + + fireEvent("slide", handleNumber, true); + fireEvent("update", handleNumber, true); + fireEvent("change", handleNumber, true); + fireEvent("set", handleNumber, true); + + if (options.events.snap) { + eventStart(event, { handleNumbers: [handleNumber] }); + } + } + + // Fires a 'hover' event for a hovered mouse/pen position. + function eventHover(event) { + var proposal = calcPointToPercentage(event.calcPoint); + + var to = scope_Spectrum.getStep(proposal); + var value = scope_Spectrum.fromStepping(to); + + Object.keys(scope_Events).forEach(function(targetEvent) { + if ("hover" === targetEvent.split(".")[0]) { + scope_Events[targetEvent].forEach(function(callback) { + callback.call(scope_Self, value); + }); + } + }); + } + + // Handles keydown on focused handles + // Don't move the document when pressing arrow keys on focused handles + function eventKeydown(event, handleNumber) { + if (isSliderDisabled() || isHandleDisabled(handleNumber)) { + return false; + } + + var horizontalKeys = ["Left", "Right"]; + var verticalKeys = ["Down", "Up"]; + var largeStepKeys = ["PageDown", "PageUp"]; + var edgeKeys = ["Home", "End"]; + + if (options.dir && !options.ort) { + // On an right-to-left slider, the left and right keys act inverted + horizontalKeys.reverse(); + } else if (options.ort && !options.dir) { + // On a top-to-bottom slider, the up and down keys act inverted + verticalKeys.reverse(); + largeStepKeys.reverse(); + } + + // Strip "Arrow" for IE compatibility. https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key + var key = event.key.replace("Arrow", ""); + + var isLargeDown = key === largeStepKeys[0]; + var isLargeUp = key === largeStepKeys[1]; + var isDown = key === verticalKeys[0] || key === horizontalKeys[0] || isLargeDown; + var isUp = key === verticalKeys[1] || key === horizontalKeys[1] || isLargeUp; + var isMin = key === edgeKeys[0]; + var isMax = key === edgeKeys[1]; + + if (!isDown && !isUp && !isMin && !isMax) { + return true; + } + + event.preventDefault(); + + var to; + + if (isUp || isDown) { + var multiplier = options.keyboardPageMultiplier; + var direction = isDown ? 0 : 1; + var steps = getNextStepsForHandle(handleNumber); + var step = steps[direction]; + + // At the edge of a slider, do nothing + if (step === null) { + return false; + } + + // No step set, use the default of 10% of the sub-range + if (step === false) { + step = scope_Spectrum.getDefaultStep( + scope_Locations[handleNumber], + isDown, + options.keyboardDefaultStep + ); + } + + if (isLargeUp || isLargeDown) { + step *= multiplier; + } + + // Step over zero-length ranges (#948); + step = Math.max(step, 0.0000001); + + // Decrement for down steps + step = (isDown ? -1 : 1) * step; + + to = scope_Values[handleNumber] + step; + } else if (isMax) { + // End key + to = options.spectrum.xVal[options.spectrum.xVal.length - 1]; + } else { + // Home key + to = options.spectrum.xVal[0]; + } + + setHandle(handleNumber, scope_Spectrum.toStepping(to), true, true); + + fireEvent("slide", handleNumber); + fireEvent("update", handleNumber); + fireEvent("change", handleNumber); + fireEvent("set", handleNumber); + + return false; + } + + // Attach events to several slider parts. + function bindSliderEvents(behaviour) { + // Attach the standard drag event to the handles. + if (!behaviour.fixed) { + scope_Handles.forEach(function(handle, index) { + // These events are only bound to the visual handle + // element, not the 'real' origin element. + attachEvent(actions.start, handle.children[0], eventStart, { + handleNumbers: [index] + }); + }); + } + + // Attach the tap event to the slider base. + if (behaviour.tap) { + attachEvent(actions.start, scope_Base, eventTap, {}); + } + + // Fire hover events + if (behaviour.hover) { + attachEvent(actions.move, scope_Base, eventHover, { + hover: true + }); + } + + // Make the range draggable. + if (behaviour.drag) { + scope_Connects.forEach(function(connect, index) { + if (connect === false || index === 0 || index === scope_Connects.length - 1) { + return; + } + + var handleBefore = scope_Handles[index - 1]; + var handleAfter = scope_Handles[index]; + var eventHolders = [connect]; + + addClass(connect, options.cssClasses.draggable); + + // When the range is fixed, the entire range can + // be dragged by the handles. The handle in the first + // origin will propagate the start event upward, + // but it needs to be bound manually on the other. + if (behaviour.fixed) { + eventHolders.push(handleBefore.children[0]); + eventHolders.push(handleAfter.children[0]); + } + + eventHolders.forEach(function(eventHolder) { + attachEvent(actions.start, eventHolder, eventStart, { + handles: [handleBefore, handleAfter], + handleNumbers: [index - 1, index] + }); + }); + }); + } + } + + // Attach an event to this slider, possibly including a namespace + function bindEvent(namespacedEvent, callback) { + scope_Events[namespacedEvent] = scope_Events[namespacedEvent] || []; + scope_Events[namespacedEvent].push(callback); + + // If the event bound is 'update,' fire it immediately for all handles. + if (namespacedEvent.split(".")[0] === "update") { + scope_Handles.forEach(function(a, index) { + fireEvent("update", index); + }); + } + } + + // Undo attachment of event + function removeEvent(namespacedEvent) { + var event = namespacedEvent && namespacedEvent.split(".")[0]; + var namespace = event && namespacedEvent.substring(event.length); + + Object.keys(scope_Events).forEach(function(bind) { + var tEvent = bind.split(".")[0]; + var tNamespace = bind.substring(tEvent.length); + + if ((!event || event === tEvent) && (!namespace || namespace === tNamespace)) { + delete scope_Events[bind]; + } + }); + } + + // External event handling + function fireEvent(eventName, handleNumber, tap) { + Object.keys(scope_Events).forEach(function(targetEvent) { + var eventType = targetEvent.split(".")[0]; + + if (eventName === eventType) { + scope_Events[targetEvent].forEach(function(callback) { + callback.call( + // Use the slider public API as the scope ('this') + scope_Self, + // Return values as array, so arg_1[arg_2] is always valid. + scope_Values.map(options.format.to), + // Handle index, 0 or 1 + handleNumber, + // Un-formatted slider values + scope_Values.slice(), + // Event is fired by tap, true or false + tap || false, + // Left offset of the handle, in relation to the slider + scope_Locations.slice(), + // add the slider public API to an accessible parameter when this is unavailable + scope_Self + ); + }); + } + }); + } + + // Split out the handle positioning logic so the Move event can use it, too + function checkHandlePosition(reference, handleNumber, to, lookBackward, lookForward, getValue) { + var distance; + + // For sliders with multiple handles, limit movement to the other handle. + // Apply the margin option by adding it to the handle positions. + if (scope_Handles.length > 1 && !options.events.unconstrained) { + if (lookBackward && handleNumber > 0) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber - 1], options.margin, 0); + to = Math.max(to, distance); + } + + if (lookForward && handleNumber < scope_Handles.length - 1) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber + 1], options.margin, 1); + to = Math.min(to, distance); + } + } + + // The limit option has the opposite effect, limiting handles to a + // maximum distance from another. Limit must be > 0, as otherwise + // handles would be unmovable. + if (scope_Handles.length > 1 && options.limit) { + if (lookBackward && handleNumber > 0) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber - 1], options.limit, 0); + to = Math.min(to, distance); + } + + if (lookForward && handleNumber < scope_Handles.length - 1) { + distance = scope_Spectrum.getAbsoluteDistance(reference[handleNumber + 1], options.limit, 1); + to = Math.max(to, distance); + } + } + + // The padding option keeps the handles a certain distance from the + // edges of the slider. Padding must be > 0. + if (options.padding) { + if (handleNumber === 0) { + distance = scope_Spectrum.getAbsoluteDistance(0, options.padding[0], 0); + to = Math.max(to, distance); + } + + if (handleNumber === scope_Handles.length - 1) { + distance = scope_Spectrum.getAbsoluteDistance(100, options.padding[1], 1); + to = Math.min(to, distance); + } + } + + to = scope_Spectrum.getStep(to); + + // Limit percentage to the 0 - 100 range + to = limit(to); + + // Return false if handle can't move + if (to === reference[handleNumber] && !getValue) { + return false; + } + + return to; + } + + // Uses slider orientation to create CSS rules. a = base value; + function inRuleOrder(v, a) { + var o = options.ort; + return (o ? a : v) + ", " + (o ? v : a); + } + + // Moves handle(s) by a percentage + // (bool, % to move, [% where handle started, ...], [index in scope_Handles, ...]) + function moveHandles(upward, proposal, locations, handleNumbers) { + var proposals = locations.slice(); + + var b = [!upward, upward]; + var f = [upward, !upward]; + + // Copy handleNumbers so we don't change the dataset + handleNumbers = handleNumbers.slice(); + + // Check to see which handle is 'leading'. + // If that one can't move the second can't either. + if (upward) { + handleNumbers.reverse(); + } + + // Step 1: get the maximum percentage that any of the handles can move + if (handleNumbers.length > 1) { + handleNumbers.forEach(function(handleNumber, o) { + var to = checkHandlePosition( + proposals, + handleNumber, + proposals[handleNumber] + proposal, + b[o], + f[o], + false + ); + + // Stop if one of the handles can't move. + if (to === false) { + proposal = 0; + } else { + proposal = to - proposals[handleNumber]; + proposals[handleNumber] = to; + } + }); + } + + // If using one handle, check backward AND forward + else { + b = f = [true]; + } + + var state = false; + + // Step 2: Try to set the handles with the found percentage + handleNumbers.forEach(function(handleNumber, o) { + state = setHandle(handleNumber, locations[handleNumber] + proposal, b[o], f[o]) || state; + }); + + // Step 3: If a handle moved, fire events + if (state) { + handleNumbers.forEach(function(handleNumber) { + fireEvent("update", handleNumber); + fireEvent("slide", handleNumber); + }); + } + } + + // Takes a base value and an offset. This offset is used for the connect bar size. + // In the initial design for this feature, the origin element was 1% wide. + // Unfortunately, a rounding bug in Chrome makes it impossible to implement this feature + // in this manner: https://bugs.chromium.org/p/chromium/issues/detail?id=798223 + function transformDirection(a, b) { + return options.dir ? 100 - a - b : a; + } + + // Updates scope_Locations and scope_Values, updates visual state + function updateHandlePosition(handleNumber, to) { + // Update locations. + scope_Locations[handleNumber] = to; + + // Convert the value to the slider stepping/range. + scope_Values[handleNumber] = scope_Spectrum.fromStepping(to); + + var translation = 10 * (transformDirection(to, 0) - scope_DirOffset); + var translateRule = "translate(" + inRuleOrder(translation + "%", "0") + ")"; + + scope_Handles[handleNumber].style[options.transformRule] = translateRule; + + updateConnect(handleNumber); + updateConnect(handleNumber + 1); + } + + // Handles before the slider middle are stacked later = higher, + // Handles after the middle later is lower + // [[7] [8] .......... | .......... [5] [4] + function setZindex() { + scope_HandleNumbers.forEach(function(handleNumber) { + var dir = scope_Locations[handleNumber] > 50 ? -1 : 1; + var zIndex = 3 + (scope_Handles.length + dir * handleNumber); + scope_Handles[handleNumber].style.zIndex = zIndex; + }); + } + + // Test suggested values and apply margin, step. + function setHandle(handleNumber, to, lookBackward, lookForward) { + to = checkHandlePosition(scope_Locations, handleNumber, to, lookBackward, lookForward, false); + + if (to === false) { + return false; + } + + updateHandlePosition(handleNumber, to); + + return true; + } + + // Updates style attribute for connect nodes + function updateConnect(index) { + // Skip connects set to false + if (!scope_Connects[index]) { + return; + } + + var l = 0; + var h = 100; + + if (index !== 0) { + l = scope_Locations[index - 1]; + } + + if (index !== scope_Connects.length - 1) { + h = scope_Locations[index]; + } + + // We use two rules: + // 'translate' to change the left/top offset; + // 'scale' to change the width of the element; + // As the element has a width of 100%, a translation of 100% is equal to 100% of the parent (.noUi-base) + var connectWidth = h - l; + var translateRule = "translate(" + inRuleOrder(transformDirection(l, connectWidth) + "%", "0") + ")"; + var scaleRule = "scale(" + inRuleOrder(connectWidth / 100, "1") + ")"; + + scope_Connects[index].style[options.transformRule] = translateRule + " " + scaleRule; + } + + // Parses value passed to .set method. Returns current value if not parse-able. + function resolveToValue(to, handleNumber) { + // Setting with null indicates an 'ignore'. + // Inputting 'false' is invalid. + if (to === null || to === false || to === undefined) { + return scope_Locations[handleNumber]; + } + + // If a formatted number was passed, attempt to decode it. + if (typeof to === "number") { + to = String(to); + } + + to = options.format.from(to); + to = scope_Spectrum.toStepping(to); + + // If parsing the number failed, use the current value. + if (to === false || isNaN(to)) { + return scope_Locations[handleNumber]; + } + + return to; + } + + // Set the slider value. + function valueSet(input, fireSetEvent) { + var values = asArray(input); + var isInit = scope_Locations[0] === undefined; + + // Event fires by default + fireSetEvent = fireSetEvent === undefined ? true : !!fireSetEvent; + + // Animation is optional. + // Make sure the initial values were set before using animated placement. + if (options.animate && !isInit) { + addClassFor(scope_Target, options.cssClasses.tap, options.animationDuration); + } + + // First pass, without lookAhead but with lookBackward. Values are set from left to right. + scope_HandleNumbers.forEach(function(handleNumber) { + setHandle(handleNumber, resolveToValue(values[handleNumber], handleNumber), true, false); + }); + + var i = scope_HandleNumbers.length === 1 ? 0 : 1; + + // Secondary passes. Now that all base values are set, apply constraints. + // Iterate all handles to ensure constraints are applied for the entire slider (Issue #1009) + for (; i < scope_HandleNumbers.length; ++i) { + scope_HandleNumbers.forEach(function(handleNumber) { + setHandle(handleNumber, scope_Locations[handleNumber], true, true); + }); + } + + setZindex(); + + scope_HandleNumbers.forEach(function(handleNumber) { + fireEvent("update", handleNumber); + + // Fire the event only for handles that received a new value, as per #579 + if (values[handleNumber] !== null && fireSetEvent) { + fireEvent("set", handleNumber); + } + }); + } + + // Reset slider to initial values + function valueReset(fireSetEvent) { + valueSet(options.start, fireSetEvent); + } + + // Set value for a single handle + function valueSetHandle(handleNumber, value, fireSetEvent) { + // Ensure numeric input + handleNumber = Number(handleNumber); + + if (!(handleNumber >= 0 && handleNumber < scope_HandleNumbers.length)) { + throw new Error("noUiSlider (" + VERSION + "): invalid handle number, got: " + handleNumber); + } + + // Look both backward and forward, since we don't want this handle to "push" other handles (#960); + setHandle(handleNumber, resolveToValue(value, handleNumber), true, true); + + fireEvent("update", handleNumber); + + if (fireSetEvent) { + fireEvent("set", handleNumber); + } + } + + // Get the slider value. + function valueGet() { + var values = scope_Values.map(options.format.to); + + // If only one handle is used, return a single value. + if (values.length === 1) { + return values[0]; + } + + return values; + } + + // Removes classes from the root and empties it. + function destroy() { + for (var key in options.cssClasses) { + if (!options.cssClasses.hasOwnProperty(key)) { + continue; + } + removeClass(scope_Target, options.cssClasses[key]); + } + + while (scope_Target.firstChild) { + scope_Target.removeChild(scope_Target.firstChild); + } + + delete scope_Target.noUiSlider; + } + + function getNextStepsForHandle(handleNumber) { + var location = scope_Locations[handleNumber]; + var nearbySteps = scope_Spectrum.getNearbySteps(location); + var value = scope_Values[handleNumber]; + var increment = nearbySteps.thisStep.step; + var decrement = null; + + // If snapped, directly use defined step value + if (options.snap) { + return [ + value - nearbySteps.stepBefore.startValue || null, + nearbySteps.stepAfter.startValue - value || null + ]; + } + + // If the next value in this step moves into the next step, + // the increment is the start of the next step - the current value + if (increment !== false) { + if (value + increment > nearbySteps.stepAfter.startValue) { + increment = nearbySteps.stepAfter.startValue - value; + } + } + + // If the value is beyond the starting point + if (value > nearbySteps.thisStep.startValue) { + decrement = nearbySteps.thisStep.step; + } else if (nearbySteps.stepBefore.step === false) { + decrement = false; + } + + // If a handle is at the start of a step, it always steps back into the previous step first + else { + decrement = value - nearbySteps.stepBefore.highestStep; + } + + // Now, if at the slider edges, there is no in/decrement + if (location === 100) { + increment = null; + } else if (location === 0) { + decrement = null; + } + + // As per #391, the comparison for the decrement step can have some rounding issues. + var stepDecimals = scope_Spectrum.countStepDecimals(); + + // Round per #391 + if (increment !== null && increment !== false) { + increment = Number(increment.toFixed(stepDecimals)); + } + + if (decrement !== null && decrement !== false) { + decrement = Number(decrement.toFixed(stepDecimals)); + } + + return [decrement, increment]; + } + + // Get the current step size for the slider. + function getNextSteps() { + return scope_HandleNumbers.map(getNextStepsForHandle); + } + + // Updateable: margin, limit, padding, step, range, animate, snap + function updateOptions(optionsToUpdate, fireSetEvent) { + // Spectrum is created using the range, snap, direction and step options. + // 'snap' and 'step' can be updated. + // If 'snap' and 'step' are not passed, they should remain unchanged. + var v = valueGet(); + + var updateAble = [ + "margin", + "limit", + "padding", + "range", + "animate", + "snap", + "step", + "format", + "pips", + "tooltips" + ]; + + // Only change options that we're actually passed to update. + updateAble.forEach(function(name) { + // Check for undefined. null removes the value. + if (optionsToUpdate[name] !== undefined) { + originalOptions[name] = optionsToUpdate[name]; + } + }); + + var newOptions = testOptions(originalOptions); + + // Load new options into the slider state + updateAble.forEach(function(name) { + if (optionsToUpdate[name] !== undefined) { + options[name] = newOptions[name]; + } + }); + + scope_Spectrum = newOptions.spectrum; + + // Limit, margin and padding depend on the spectrum but are stored outside of it. (#677) + options.margin = newOptions.margin; + options.limit = newOptions.limit; + options.padding = newOptions.padding; + + // Update pips, removes existing. + if (options.pips) { + pips(options.pips); + } else { + removePips(); + } + + // Update tooltips, removes existing. + if (options.tooltips) { + tooltips(); + } else { + removeTooltips(); + } + + // Invalidate the current positioning so valueSet forces an update. + scope_Locations = []; + valueSet(optionsToUpdate.start || v, fireSetEvent); + } + + // Initialization steps + function setupSlider() { + // Create the base element, initialize HTML and set classes. + // Add handles and connect elements. + scope_Base = addSlider(scope_Target); + + addElements(options.connect, scope_Base); + + // Attach user events. + bindSliderEvents(options.events); + + // Use the public value method to set the start values. + valueSet(options.start); + + if (options.pips) { + pips(options.pips); + } + + if (options.tooltips) { + tooltips(); + } + + aria(); + } + + setupSlider(); + + // noinspection JSUnusedGlobalSymbols + scope_Self = { + destroy: destroy, + steps: getNextSteps, + on: bindEvent, + off: removeEvent, + get: valueGet, + set: valueSet, + setHandle: valueSetHandle, + reset: valueReset, + // Exposed for unit testing, don't use this in your application. + __moveHandles: function(a, b, c) { + moveHandles(a, b, scope_Locations, c); + }, + options: originalOptions, // Issue #600, #678 + updateOptions: updateOptions, + target: scope_Target, // Issue #597 + removePips: removePips, + removeTooltips: removeTooltips, + getTooltips: function() { + return scope_Tooltips; + }, + getOrigins: function() { + return scope_Handles; + }, + pips: pips // Issue #594 + }; + + return scope_Self; + } + + // Run the standard initializer + function initialize(target, originalOptions) { + if (!target || !target.nodeName) { + throw new Error("noUiSlider (" + VERSION + "): create requires a single element, got: " + target); + } + + // Throw an error if the slider was already initialized. + if (target.noUiSlider) { + throw new Error("noUiSlider (" + VERSION + "): Slider was already initialized."); + } + + // Test the options and create the slider environment; + var options = testOptions(originalOptions, target); + var api = scope(target, options, originalOptions); + + target.noUiSlider = api; + + return api; + } + + // Use an object instead of a function for future expandability; + return { + // Exposed for unit testing, don't use this in your application. + __spectrum: Spectrum, + version: VERSION, + // A reference to the default classes, allows global changes. + // Use the cssClasses option for changes to one slider. + cssClasses: cssClasses, + create: initialize + }; +}); diff --git a/vcm/templates/custom.css b/vcm/templates/custom.css index f1ae5e61b39abadd82be1055ed734eceaa8325e0..c2dca82679a3aa6a110316cc67b49daeb16f9863 100644 --- a/vcm/templates/custom.css +++ b/vcm/templates/custom.css @@ -445,4 +445,28 @@ div.tour-top-navi { box-shadow: inset 0 1px 0 rgba(255,255,255,0.2), 0 0 8px rgba(0,0,0,0.3), 0 8px 8px rgba(0,0,0,0.3), inset -1px 0 1px #b9f3fe; -webkit-transition: all .5s ease; transition: all .5s ease; -} \ No newline at end of file +} + + + + + + +.infobtn { + border: none; + /* color: grey; */ + /* padding: 12px 16px; */ + /* font-size: 16px; */ + cursor: pointer; + float:right; + background-color:rgb(60, 60, 60); + } + + .infobtn:before { + content: url(../images/Info.svg); + width: 20px; + float: right; + /* margin-right: 5px; */ + /* margin-top: -2px; */ + } + diff --git a/vcm/templates/custom.js b/vcm/templates/custom.js index 250c2110914a57510a226e967e2ffdc56dd2b7d5..6f1700a1864396839c3453e28243ad25d5fc3db6 100644 --- a/vcm/templates/custom.js +++ b/vcm/templates/custom.js @@ -55,6 +55,7 @@ function showtourSpecific(specify) { // para.innerHTML = "This is a paragraph."; // document.getElementById("old").innerHTML = para.innerHTML; document.getElementById("UmfrageOne").style.display = "none"; + document.getElementById("NordbahnhofInfo").style.display = "none"; document.getElementById("Energiekonzept").style.display = "none"; document.getElementById("projektOne").style.display = "block"; showTour(); @@ -103,6 +104,7 @@ function EnergiekonzeptFunction(content){ document.getElementById("UmfrageOne").style.display = "none"; + document.getElementById("NordbahnhofInfo").style.display = "none"; document.getElementById("projektOne").style.display = "none"; document.getElementById("Energiekonzept").style.display = "block"; showTour(); @@ -206,6 +208,7 @@ function Questionnaire() { document.getElementById("projektOne").style.display = "none"; document.getElementById("Energiekonzept").style.display = "none"; + document.getElementById("NordbahnhofInfo").style.display = "none"; document.getElementById("UmfrageOne").style.display = "block"; showTour(); @@ -221,3 +224,12 @@ function goHome(){ //stopStory() vcs.vcm.Framework.getInstance().getActiveMap().gotoViewPoint(viewp) } + +//--------------------------------------------------------------------------------------- +function NordbahnhofText() { + document.getElementById("projektOne").style.display = "none"; + document.getElementById("Energiekonzept").style.display = "none"; + document.getElementById("UmfrageOne").style.display = "none"; + document.getElementById("NordbahnhofInfo").style.display = "block"; + showTour(); +} \ No newline at end of file diff --git a/vcm/templates/newDevBahn.js b/vcm/templates/newDevBahn.js index 0071d4b37e0391fa3b06e8b03c20349a043d6743..c80b8c8491ea4f15b4a6930e11c67f316c4ca8ab 100644 --- a/vcm/templates/newDevBahn.js +++ b/vcm/templates/newDevBahn.js @@ -1,3 +1,8 @@ +var heatdemVal01 = 100 +var heatdemVal02 = 200 +var heatdemVal03 = 300 +var heatdemVal04 = 400 + function oldZust(){ @@ -281,11 +286,11 @@ function oldZust(){ tileset.style = new Cesium.Cesium3DTileStyle({ color: { conditions: [ - ["(${Specificspaceheatingdemand} > 0) && (${Specificspaceheatingdemand} < 100)", "color('#38943d')"], - ["(${Specificspaceheatingdemand} >= 100) && (${Specificspaceheatingdemand} < 200)", "color('#699438')"], - ["(${Specificspaceheatingdemand} >= 200) && (${Specificspaceheatingdemand} < 300)", "color('#d0d40b')"], - ["(${Specificspaceheatingdemand} >= 300) && (${Specificspaceheatingdemand} < 400)", "color('#db6f09')"], - ["(${Specificspaceheatingdemand} >= 400) && (${Specificspaceheatingdemand} < 500)", "color('#ad0202')"], + ["(${Specificspaceheatingdemand} > 0) && (${Specificspaceheatingdemand} < " + heatdemVal01 + ")", "color('#38943d')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal01 + ") && (${Specificspaceheatingdemand} < " + heatdemVal02 + ")", "color('#699438')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal02 + ") && (${Specificspaceheatingdemand} < " + heatdemVal03 + ")", "color('#d0d40b')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal03 + ") && (${Specificspaceheatingdemand} < " + heatdemVal04 + ")", "color('#db6f09')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal04 + ") && (${Specificspaceheatingdemand} < 500)", "color('#ad0202')"], ["true", "color('#77a1b9')"], ], }, @@ -312,18 +317,11 @@ function oldZust(){ conditions: [ ["${gml_id} === 'DEBW522AA0001fd8a'", "color('#FFFFFF')"], ["${gml_id} === 'DEBW522AA00016448'", "color('#FFFFFF')"], - // ["(${citygml_measured_height} >= 1.0)", "color('#1a9641')"], - //["(${Specificspaceheatingdemand } > 287.3)", "color('#000000')"], - // ["(${Specific space heating demand} > 0) && (${Specific space heating demand} < 60)", "color('#33ACFF')"], - // ["(${Specific space heating demand} >= 60) && (${Specific space heating demand} < 120)", "color('#2AFF00')"], - // ["(${Specific space heating demand} >= 120) && (${Specific space heating demand} < 170)", "color('#FFFF00')"], - // ["(${Specific space heating demand} >= 170) && (${Specific space heating demand} < 230)", "color('#FFA200')"], - // ["(${Specific_space_heating_demand} >= 230)", "color('#FF0000')"] - ["(${Specificspaceheatingdemand} > 70) && (${Specificspaceheatingdemand} < 100)", "color('#38943d')"], - ["(${Specificspaceheatingdemand} >= 100) && (${Specificspaceheatingdemand} < 200)", "color('#699438')"], - ["(${Specificspaceheatingdemand} >= 200) && (${Specificspaceheatingdemand} < 300)", "color('#d0d40b')"], - ["(${Specificspaceheatingdemand} >= 300) && (${Specificspaceheatingdemand} < 400)", "color('#db6f09')"], - ["(${Specificspaceheatingdemand} >= 400) && (${Specificspaceheatingdemand} < 500)", "color('#ad0202')"], + ["(${Specificspaceheatingdemand} > 0) && (${Specificspaceheatingdemand} < " + heatdemVal01 + ")", "color('#38943d')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal01 + ") && (${Specificspaceheatingdemand} < " + heatdemVal02 + ")", "color('#699438')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal02 + ") && (${Specificspaceheatingdemand} < " + heatdemVal03 + ")", "color('#d0d40b')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal03 + ") && (${Specificspaceheatingdemand} < " + heatdemVal04 + ")", "color('#db6f09')"], + ["(${Specificspaceheatingdemand} >= " + heatdemVal04 + ") && (${Specificspaceheatingdemand} < 500)", "color('#ad0202')"], ["true", "color('#77a1b9')"], ], }, @@ -337,4 +335,8 @@ function oldZust(){ // console.log("layer.highlight({" + idtext + ":Cesium.Color.fromCssColorString('#BB8FCE')})") // } - } \ No newline at end of file + } + + + + \ No newline at end of file diff --git a/vcm/templates/slider.js b/vcm/templates/slider.js new file mode 100644 index 0000000000000000000000000000000000000000..2171c76d0694ca5ce0a4ca7daab3f0aad66c7640 --- /dev/null +++ b/vcm/templates/slider.js @@ -0,0 +1,79 @@ +var unconstrainedSlider = document.getElementById('unconstrained'); +var unconstrainedValues = document.getElementById('unconstrained-values'); +var value01html = document.getElementById('One') +var value02html = document.getElementById('Two') +var value03html = document.getElementById('Three') +var value04html = document.getElementById('Four') +var value05html = document.getElementById('Five') + +noUiSlider.create(unconstrainedSlider, { + start: [100, 200, 300, 400], + // behaviour: 'unconstrained-tap', + connect: [true, true, true, true, true], + range: { + 'min': 0, + 'max': 500 + } +}); + +var connect = unconstrainedSlider.querySelectorAll('.noUi-connect'); +var classes = ['c-1-color', 'c-2-color', 'c-3-color', 'c-4-color', 'c-5-color']; + +for (var i = 0; i < connect.length; i++) { + connect[i].classList.add(classes[i]); +} + + +unconstrainedSlider.noUiSlider.on('update', function (values) { + // unconstrainedValues.innerHTML = values.join(' :: '); + value01html.innerHTML = "min - " + values[0]; + value02html.innerHTML = values[0] + " - " + values[1]; + value03html.innerHTML = values[1] + " - " + values[2]; + value04html.innerHTML = values[2] + " - " + values[3]; + value05html.innerHTML = values[3] + " - max"; + + var chk_ceil= document.getElementById("chxboxDemand"); + if(chk_ceil.checked == true){ + + heatdemVal01 = values[0]; + heatdemVal02 = values[1]; + heatdemVal03 = values[2]; + heatdemVal04 = values[3]; + + + highlightEnergy(); + } + +}); + +// var testingslider = document.getElementById('slider-color'); + +// noUiSlider.create(testingslider, { +// start: slidervalues = [60, 100, 200, 300], +// connect: [true, true, true, true, true], +// range: { +// 'min': [0], +// 'max': [600] +// } +// }); + +// var connect = testingslider.querySelectorAll('.noUi-connect'); +// var classes = ['c-1-color', 'c-2-color', 'c-3-color', 'c-4-color', 'c-5-color']; + +// for (var i = 0; i < connect.length; i++) { +// connect[i].classList.add(classes[i]); +// } + + +// function checkSlider(){ + +// } +// // Display the slider value and how far the handle moved +// // from the left edge of the slider. +// range.noUiSlider.on('update', function (values) { +// // valuesDivs[handle].innerHTML = values[handle]; +// // diffDivs[0].innerHTML = values[1] - values[0]; +// // diffDivs[1].innerHTML = values[2] - values[1]; +// // diffDivs[2].innerHTML = values[3] - values[2]; +// alert(values[0]) +// }); \ No newline at end of file diff --git a/vcm/templates/sliders.css b/vcm/templates/sliders.css new file mode 100644 index 0000000000000000000000000000000000000000..f4f147400993678a366ed74c01b44dc1a2a8871b --- /dev/null +++ b/vcm/templates/sliders.css @@ -0,0 +1,68 @@ + /* slider */ + /* ------------------------------- */ + .c-1-color { background: #38943d; } + .c-2-color { background: #699438; } + .c-3-color { background: #d0d40b; } + .c-4-color { background: #db6f09; } + .c-5-color { background: #ad0202; } + + .rectangle { + height: 50px; + width: 100px; + + } +#One{ + background-color: #38943d; +} +#Two{ + background-color: #699438; +} +#Three{ + background-color: #d0d40b; +} +#Four{ + background-color: #db6f09; +} +#Five{ + background-color: #ad0202; +} + +.my-legend .legend-title { + text-align: left; + margin-bottom: 5px; + font-weight: bold; + font-size: 90%; + } + .my-legend .legend-scale ul { + margin: 0; + margin-bottom: 5px; + padding: 0; + float: left; + list-style: none; + } + .my-legend .legend-scale ul li { + font-size: 100%; + list-style: none; + margin-left: 0; + line-height: 30px; + width:150px; + margin-bottom: 2px; + font-weight: bold; + } + .my-legend ul.legend-labels li span { + display: block; + float: left; + height: 30px; + width: 70px; + margin-right: 5px; + margin-left: 0; + border: 1px solid #999; + } + .my-legend .legend-source { + font-size: 90%; + color: rgb(0, 0, 0); + clear: both; + } + .my-legend a { + color: rgb(0, 0, 0); + } \ No newline at end of file