A lightweight controller library for JavaScript. It allows you to easily manipulate variables and fire functions on the fly.
An "abstract" class that represents a given property of an object.
dat.controllers.ControllerRepresents a given property of an object that is a number.
DOMElement
* [.parent](#GUI+parent) : dat.gui.GUI
* [.autoPlace](#GUI+autoPlace) : Boolean
* [.closeOnTop](#GUI+closeOnTop) : Boolean
* [.preset](#GUI+preset) : String
* [.width](#GUI+width) : Number
* [.name](#GUI+name) : String
* [.closed](#GUI+closed) : Boolean
* [.load](#GUI+load) : Object
* [.useLocalStorage](#GUI+useLocalStorage) : Boolean
* [.add(object, property, [min], [max], [step])](#GUI+add) ⇒ [Controller](#Controller)
* [.addColor(object, property)](#GUI+addColor) ⇒ [Controller](#Controller)
* [.remove(controller)](#GUI+remove)
* [.destroy()](#GUI+destroy)
* [.addFolder(name)](#GUI+addFolder) ⇒ dat.gui.GUI
* [.removeFolder(folder)](#GUI+removeFolder)
* [.open()](#GUI+open)
* [.close()](#GUI+close)
* [.hide()](#GUI+hide)
* [.show()](#GUI+show)
* [.getRoot()](#GUI+getRoot) ⇒ dat.gui.GUI
* [.getSaveObject()](#GUI+getSaveObject) ⇒ Object
### new GUI([params])
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [params] | Object | | |
| [params.name] | String | | The name of this GUI. |
| [params.load] | Object | | JSON object representing the saved state of this GUI. |
| [params.parent] | dat.gui.GUI | | The GUI I'm nested in. |
| [params.autoPlace] | Boolean | true | |
| [params.hideable] | Boolean | true | If true, GUI is shown/hidden by h keypress. |
| [params.closed] | Boolean | false | If true, starts closed |
| [params.closeOnTop] | Boolean | false | If true, close/open button shows on top of the GUI |
**Example**
```js
// Creating a GUI with options.
var gui = new dat.GUI({name: 'My GUI'});
```
**Example**
```js
// Creating a GUI and a subfolder.
var gui = new dat.GUI();
var folder1 = gui.addFolder('Flow Field');
```
### gui.domElement : DOMElement
Outermost DOM Element
**Kind**: instance property of [GUI](#GUI)
### gui.parent : dat.gui.GUI
The parent GUI
**Kind**: instance property of [GUI](#GUI)
### gui.autoPlace : Boolean
Handles GUI's element placement for you
**Kind**: instance property of [GUI](#GUI)
### gui.closeOnTop : Boolean
Handles GUI's position of open/close button
**Kind**: instance property of [GUI](#GUI)
### gui.preset : String
The identifier for a set of saved values
**Kind**: instance property of [GUI](#GUI)
### gui.width : Number
The width of GUI element
**Kind**: instance property of [GUI](#GUI)
### gui.name : String
The name of GUI. Used for folders. i.e
a folder's name
**Kind**: instance property of [GUI](#GUI)
### gui.closed : Boolean
Whether the GUI is collapsed or not
**Kind**: instance property of [GUI](#GUI)
### gui.load : Object
Contains all presets
**Kind**: instance property of [GUI](#GUI)
### gui.useLocalStorage : Boolean
Determines whether or not to use localStorage as the means for
remembering
**Kind**: instance property of [GUI](#GUI)
### gui.add(object, property, [min], [max], [step]) ⇒ [Controller](#Controller)
Adds a new [Controller](#Controller) to the GUI. The type of controller created
is inferred from the initial value of object[property]. For
color properties, see [addColor](addColor).
**Kind**: instance method of [GUI](#GUI)
**Returns**: [Controller](#Controller) - The controller that was added to the GUI.
| Param | Type | Description |
| --- | --- | --- |
| object | Object | The object to be manipulated |
| property | String | The name of the property to be manipulated |
| [min] | Number | Minimum allowed value |
| [max] | Number | Maximum allowed value |
| [step] | Number | Increment by which to change value |
**Example**
```js
// Add a string controller.
var person = {name: 'Sam'};
gui.add(person, 'name');
```
**Example**
```js
// Add a number controller slider.
var person = {age: 45};
gui.add(person, 'age', 0, 100);
```
### gui.addColor(object, property) ⇒ [Controller](#Controller)
Adds a new color controller to the GUI.
**Kind**: instance method of [GUI](#GUI)
**Returns**: [Controller](#Controller) - The controller that was added to the GUI.
| Param |
| --- |
| object |
| property |
**Example**
```js
var palette = {
color1: '#FF0000', // CSS string
color2: [ 0, 128, 255 ], // RGB array
color3: [ 0, 128, 255, 0.3 ], // RGB with alpha
color4: { h: 350, s: 0.9, v: 0.3 } // Hue, saturation, value
};
gui.addColor(palette, 'color1');
gui.addColor(palette, 'color2');
gui.addColor(palette, 'color3');
gui.addColor(palette, 'color4');
```
### gui.remove(controller)
Removes the given controller from the GUI.
**Kind**: instance method of [GUI](#GUI)
| Param | Type |
| --- | --- |
| controller | [Controller](#Controller) |
### gui.destroy()
Removes the root GUI from the document and unbinds all event listeners.
For subfolders, use `gui.removeFolder(folder)` instead.
**Kind**: instance method of [GUI](#GUI)
### gui.addFolder(name) ⇒ dat.gui.GUI
Creates a new subfolder GUI instance.
**Kind**: instance method of [GUI](#GUI)
**Returns**: dat.gui.GUI - The new folder.
**Throws**:
- Error if this GUI already has a folder by the specified
name
| Param |
| --- |
| name |
### gui.removeFolder(folder)
Removes a subfolder GUI instance.
**Kind**: instance method of [GUI](#GUI)
| Param | Type | Description |
| --- | --- | --- |
| folder | dat.gui.GUI | The folder to remove. |
### gui.open()
Opens the GUI.
**Kind**: instance method of [GUI](#GUI)
### gui.close()
Closes the GUI.
**Kind**: instance method of [GUI](#GUI)
### gui.hide()
Hides the GUI.
**Kind**: instance method of [GUI](#GUI)
### gui.show()
Shows the GUI.
**Kind**: instance method of [GUI](#GUI)
### gui.getRoot() ⇒ dat.gui.GUI
**Kind**: instance method of [GUI](#GUI)
**Returns**: dat.gui.GUI - the topmost parent GUI of a nested GUI.
### gui.getSaveObject() ⇒ Object
**Kind**: instance method of [GUI](#GUI)
**Returns**: Object - a JSON object representing the current state of
this GUI as well as its remembered properties.
## Controller
An "abstract" class that represents a given property of an object.
**Kind**: global class
* [Controller](#Controller)
* [new Controller(object, property)](#new_Controller_new)
* [.domElement](#Controller+domElement) : DOMElement
* [.object](#Controller+object) : Object
* [.property](#Controller+property) : String
* [.options(options)](#Controller+options) ⇒ [Controller](#Controller)
* [.name(name)](#Controller+name) ⇒ [Controller](#Controller)
* [.listen()](#Controller+listen) ⇒ [Controller](#Controller)
* [.remove()](#Controller+remove) ⇒ [Controller](#Controller)
* [.onChange(fnc)](#Controller+onChange) ⇒ [Controller](#Controller)
* [.onFinishChange(fnc)](#Controller+onFinishChange) ⇒ [Controller](#Controller)
* [.setValue(newValue)](#Controller+setValue)
* [.getValue()](#Controller+getValue) ⇒ Object
* [.updateDisplay()](#Controller+updateDisplay) ⇒ [Controller](#Controller)
* [.isModified()](#Controller+isModified) ⇒ Boolean
### new Controller(object, property)
| Param | Type | Description |
| --- | --- | --- |
| object | Object | The object to be manipulated |
| property | string | The name of the property to be manipulated |
### controller.domElement : DOMElement
Those who extend this class will put their DOM elements in here.
**Kind**: instance property of [Controller](#Controller)
### controller.object : Object
The object to manipulate
**Kind**: instance property of [Controller](#Controller)
### controller.property : String
The name of the property to manipulate
**Kind**: instance property of [Controller](#Controller)
### controller.options(options) ⇒ [Controller](#Controller)
**Kind**: instance method of [Controller](#Controller)
| Param | Type |
| --- | --- |
| options | Array \| Object |
### controller.name(name) ⇒ [Controller](#Controller)
Sets the name of the controller.
**Kind**: instance method of [Controller](#Controller)
| Param | Type |
| --- | --- |
| name | string |
### controller.listen() ⇒ [Controller](#Controller)
Sets controller to listen for changes on its underlying object.
**Kind**: instance method of [Controller](#Controller)
### controller.remove() ⇒ [Controller](#Controller)
Removes the controller from its parent GUI.
**Kind**: instance method of [Controller](#Controller)
### controller.onChange(fnc) ⇒ [Controller](#Controller)
Specify that a function fire every time someone changes the value with
this Controller.
**Kind**: instance method of [Controller](#Controller)
**Returns**: [Controller](#Controller) - this
| Param | Type | Description |
| --- | --- | --- |
| fnc | function | This function will be called whenever the value is modified via this Controller. |
### controller.onFinishChange(fnc) ⇒ [Controller](#Controller)
Specify that a function fire every time someone "finishes" changing
the value wih this Controller. Useful for values that change
incrementally like numbers or strings.
**Kind**: instance method of [Controller](#Controller)
**Returns**: [Controller](#Controller) - this
| Param | Type | Description |
| --- | --- | --- |
| fnc | function | This function will be called whenever someone "finishes" changing the value via this Controller. |
### controller.setValue(newValue)
Change the value of object[property]
**Kind**: instance method of [Controller](#Controller)
| Param | Type | Description |
| --- | --- | --- |
| newValue | Object | The new value of object[property] |
### controller.getValue() ⇒ Object
Gets the value of object[property]
**Kind**: instance method of [Controller](#Controller)
**Returns**: Object - The current value of object[property]
### controller.updateDisplay() ⇒ [Controller](#Controller)
Refreshes the visual display of a Controller in order to keep sync
with the object's current value.
**Kind**: instance method of [Controller](#Controller)
**Returns**: [Controller](#Controller) - this
### controller.isModified() ⇒ Boolean
**Kind**: instance method of [Controller](#Controller)
**Returns**: Boolean - true if the value has deviated from initialValue
## NumberController ⇐ dat.controllers.Controller
Represents a given property of an object that is a number.
**Kind**: global class
**Extends**: dat.controllers.Controller
* [NumberController](#NumberController) ⇐ dat.controllers.Controller
* [new NumberController(object, property, [params])](#new_NumberController_new)
* [.min(minValue)](#NumberController+min) ⇒ dat.controllers.NumberController
* [.max(maxValue)](#NumberController+max) ⇒ dat.controllers.NumberController
* [.step(stepValue)](#NumberController+step) ⇒ dat.controllers.NumberController
### new NumberController(object, property, [params])
| Param | Type | Description |
| --- | --- | --- |
| object | Object | The object to be manipulated |
| property | string | The name of the property to be manipulated |
| [params] | Object | Optional parameters |
| [params.min] | Number | Minimum allowed value |
| [params.max] | Number | Maximum allowed value |
| [params.step] | Number | Increment by which to change value |
### numberController.min(minValue) ⇒ dat.controllers.NumberController
Specify a minimum value for object[property].
**Kind**: instance method of [NumberController](#NumberController)
**Returns**: dat.controllers.NumberController - this
| Param | Type | Description |
| --- | --- | --- |
| minValue | Number | The minimum value for object[property] |
### numberController.max(maxValue) ⇒ dat.controllers.NumberController
Specify a maximum value for object[property].
**Kind**: instance method of [NumberController](#NumberController)
**Returns**: dat.controllers.NumberController - this
| Param | Type | Description |
| --- | --- | --- |
| maxValue | Number | The maximum value for object[property] |
### numberController.step(stepValue) ⇒ dat.controllers.NumberController
Specify a step value that dat.controllers.NumberController
increments by.
**Kind**: instance method of [NumberController](#NumberController)
**Default**: if minimum and maximum specified increment is 1% of the
difference otherwise stepValue is 1
**Returns**: dat.controllers.NumberController - this
| Param | Type | Description |
| --- | --- | --- |
| stepValue | Number | The step value for dat.controllers.NumberController |
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2014, Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
# dat.GUI
A lightweight graphical user interface for changing variables in JavaScript.
Get started with dat.GUI by reading the [API documentation](API.md).
## Packaged Builds
The easiest way to use dat.GUI in your code is by using the built source at `build/dat.gui.min.js`. These built JavaScript files bundle all the necessary dependencies to run dat.GUI.
In your `head` tag, include the following code:
```html
```
## Installing from npm
```bash
$ npm install --save dat.gui
```
```js
// CommonJS:
const dat = require('dat.gui');
// ES6:
import * as dat from 'dat.gui';
const gui = new dat.GUI();
```
## Directory Contents
```
├── build - Compiled source code.
├── src - Source files.
└── tests - Tests.
```
## Building your own dat.GUI
In the terminal, enter the following:
```
$ npm install
$ npm run build
```
## npm scripts
- npm run build - Build development and production version of scripts.
- npm run dev - Build development version of script and watch for changes.
## Working with Content Security Policy
If you're using a server with a Content Security Policy in place that blocks 'unsafe-inline', you will have problems when dat.gui.js tries to inject style information. To get around this, load 'build/dat.gui.css' as an external style sheet.
## Changes
View the [Change Log](https://github.com/dataarts/dat.gui)
## Thanks
The following libraries / open-source projects were used in the development of dat.GUI:
* [Rollup](https://rollupjs.org)
* [Sass](http://sass-lang.com/)
* [Node.js](http://nodejs.org/)
* [QUnit](https://github.com/jquery/qunit) / [jquery](http://jquery.com/)
================================================
FILE: bower.json
================================================
{
"name": "dat.gui",
"homepage": "https://github.com/dataarts/dat.gui.git",
"authors": [
"Google Data Arts Team GUI's constructor:\n\n \n\n localStorage on exit.\n\n localStorage will\n override those passed to dat.GUI's constructor. This makes it\n easier to work incrementally, but localStorage is fragile,\n and your friends may not see the same values you do.\n\n GUI's constructor:\n\n \n\n localStorage on exit.\n\n localStorage will\n override those passed to dat.GUI's constructor. This makes it\n easier to work incrementally, but localStorage is fragile,\n and your friends may not see the same values you do.\n\n object[property]
*
* @param {Object} newValue The new value of object[property]
*/
setValue(newValue) {
this.object[this.property] = newValue;
if (this.__onChange) {
this.__onChange.call(this, newValue);
}
this.updateDisplay();
return this;
}
/**
* Gets the value of object[property]
*
* @returns {Object} The current value of object[property]
*/
getValue() {
return this.object[this.property];
}
/**
* Refreshes the visual display of a Controller in order to keep sync
* with the object's current value.
* @returns {Controller} this
*/
updateDisplay() {
return this;
}
/**
* @returns {boolean} true if the value has deviated from initialValue
*/
isModified() {
return this.initialValue !== this.getValue();
}
}
export default Controller;
================================================
FILE: src/dat/controllers/ControllerFactory.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import OptionController from './OptionController';
import NumberControllerBox from './NumberControllerBox';
import NumberControllerSlider from './NumberControllerSlider';
import StringController from './StringController';
import FunctionController from './FunctionController';
import BooleanController from './BooleanController';
import common from '../utils/common';
const ControllerFactory = function(object, property) {
const initialValue = object[property];
// Providing options?
if (common.isArray(arguments[2]) || common.isObject(arguments[2])) {
return new OptionController(object, property, arguments[2]);
}
// Providing a map?
if (common.isNumber(initialValue)) {
// Has min and max? (slider)
if (common.isNumber(arguments[2]) && common.isNumber(arguments[3])) {
// has step?
if (common.isNumber(arguments[4])) {
return new NumberControllerSlider(object, property,
arguments[2], arguments[3], arguments[4]);
}
return new NumberControllerSlider(object, property, arguments[2], arguments[3]);
}
// number box
if (common.isNumber(arguments[4])) { // has step
return new NumberControllerBox(object, property,
{ min: arguments[2], max: arguments[3], step: arguments[4] });
}
return new NumberControllerBox(object, property, { min: arguments[2], max: arguments[3] });
}
if (common.isString(initialValue)) {
return new StringController(object, property);
}
if (common.isFunction(initialValue)) {
return new FunctionController(object, property, '');
}
if (common.isBoolean(initialValue)) {
return new BooleanController(object, property);
}
return null;
};
export default ControllerFactory;
================================================
FILE: src/dat/controllers/FunctionController.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import Controller from './Controller';
import dom from '../dom/dom';
/**
* @class Provides a GUI interface to fire a specified method, a property of an object.
*
* @extends dat.controllers.Controller
*
* @param {Object} object The object to be manipulated
* @param {string} property The name of the property to be manipulated
*/
class FunctionController extends Controller {
constructor(object, property, text) {
super(object, property);
const _this = this;
this.__button = document.createElement('div');
this.__button.innerHTML = text === undefined ? 'Fire' : text;
dom.bind(this.__button, 'click', function(e) {
e.preventDefault();
_this.fire();
return false;
});
dom.addClass(this.__button, 'button');
this.domElement.appendChild(this.__button);
}
fire() {
if (this.__onChange) {
this.__onChange.call(this);
}
this.getValue().call(this.object);
if (this.__onFinishChange) {
this.__onFinishChange.call(this, this.getValue());
}
}
}
export default FunctionController;
================================================
FILE: src/dat/controllers/NumberController.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import Controller from './Controller';
import common from '../utils/common';
function numDecimals(x) {
const _x = x.toString();
if (_x.indexOf('.') > -1) {
return _x.length - _x.indexOf('.') - 1;
}
return 0;
}
/**
* @class Represents a given property of an object that is a number.
*
* @extends dat.controllers.Controller
*
* @param {Object} object The object to be manipulated
* @param {string} property The name of the property to be manipulated
* @param {Object} [params] Optional parameters
* @param {Number} [params.min] Minimum allowed value
* @param {Number} [params.max] Maximum allowed value
* @param {Number} [params.step] Increment by which to change value
*/
class NumberController extends Controller {
constructor(object, property, params) {
super(object, property);
const _params = params || {};
this.__min = _params.min;
this.__max = _params.max;
this.__step = _params.step;
if (common.isUndefined(this.__step)) {
if (this.initialValue === 0) {
this.__impliedStep = 1; // What are we, psychics?
} else {
// Hey Doug, check this out.
this.__impliedStep = Math.pow(10, Math.floor(Math.log(Math.abs(this.initialValue)) / Math.LN10)) / 10;
}
} else {
this.__impliedStep = this.__step;
}
this.__precision = numDecimals(this.__impliedStep);
}
setValue(v) {
let _v = v;
if (this.__min !== undefined && _v < this.__min) {
_v = this.__min;
} else if (this.__max !== undefined && _v > this.__max) {
_v = this.__max;
}
if (this.__step !== undefined && _v % this.__step !== 0) {
_v = Math.round(_v / this.__step) * this.__step;
}
return super.setValue(_v);
}
/**
* Specify a minimum value for object[property].
*
* @param {Number} minValue The minimum value for
* object[property]
* @returns {dat.controllers.NumberController} this
*/
min(minValue) {
this.__min = minValue;
return this;
}
/**
* Specify a maximum value for object[property].
*
* @param {Number} maxValue The maximum value for
* object[property]
* @returns {dat.controllers.NumberController} this
*/
max(maxValue) {
this.__max = maxValue;
return this;
}
/**
* Specify a step value that dat.controllers.NumberController
* increments by.
*
* @param {Number} stepValue The step value for
* dat.controllers.NumberController
* @default if minimum and maximum specified increment is 1% of the
* difference otherwise stepValue is 1
* @returns {dat.controllers.NumberController} this
*/
step(stepValue) {
this.__step = stepValue;
this.__impliedStep = stepValue;
this.__precision = numDecimals(stepValue);
return this;
}
}
export default NumberController;
================================================
FILE: src/dat/controllers/NumberControllerBox.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import NumberController from './NumberController';
import dom from '../dom/dom';
import common from '../utils/common';
function roundToDecimal(value, decimals) {
const tenTo = Math.pow(10, decimals);
return Math.round(value * tenTo) / tenTo;
}
/**
* @class Represents a given property of an object that is a number and
* provides an input element with which to manipulate it.
*
* @extends dat.controllers.Controller
* @extends dat.controllers.NumberController
*
* @param {Object} object The object to be manipulated
* @param {string} property The name of the property to be manipulated
* @param {Object} [params] Optional parameters
* @param {Number} [params.min] Minimum allowed value
* @param {Number} [params.max] Maximum allowed value
* @param {Number} [params.step] Increment by which to change value
*/
class NumberControllerBox extends NumberController {
constructor(object, property, params) {
super(object, property, params);
this.__truncationSuspended = false;
const _this = this;
/**
* {Number} Previous mouse y position
* @ignore
*/
let prevY;
function onChange() {
const attempted = parseFloat(_this.__input.value);
if (!common.isNaN(attempted)) {
_this.setValue(attempted);
}
}
function onFinish() {
if (_this.__onFinishChange) {
_this.__onFinishChange.call(_this, _this.getValue());
}
}
function onBlur() {
onFinish();
}
function onMouseDrag(e) {
const diff = prevY - e.clientY;
_this.setValue(_this.getValue() + diff * _this.__impliedStep);
prevY = e.clientY;
}
function onMouseUp() {
dom.unbind(window, 'mousemove', onMouseDrag);
dom.unbind(window, 'mouseup', onMouseUp);
onFinish();
}
function onMouseDown(e) {
dom.bind(window, 'mousemove', onMouseDrag);
dom.bind(window, 'mouseup', onMouseUp);
prevY = e.clientY;
}
this.__input = document.createElement('input');
this.__input.setAttribute('type', 'text');
// Makes it so manually specified values are not truncated.
dom.bind(this.__input, 'change', onChange);
dom.bind(this.__input, 'blur', onBlur);
dom.bind(this.__input, 'mousedown', onMouseDown);
dom.bind(this.__input, 'keydown', function(e) {
// When pressing enter, you can be as precise as you want.
if (e.keyCode === 13) {
_this.__truncationSuspended = true;
this.blur();
_this.__truncationSuspended = false;
onFinish();
}
});
this.updateDisplay();
this.domElement.appendChild(this.__input);
}
updateDisplay() {
this.__input.value = this.__truncationSuspended ? this.getValue() : roundToDecimal(this.getValue(), this.__precision);
return super.updateDisplay();
}
}
export default NumberControllerBox;
================================================
FILE: src/dat/controllers/NumberControllerSlider.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import NumberController from './NumberController';
import dom from '../dom/dom';
function map(v, i1, i2, o1, o2) {
return o1 + (o2 - o1) * ((v - i1) / (i2 - i1));
}
/**
* @class Represents a given property of an object that is a number, contains
* a minimum and maximum, and provides a slider element with which to
* manipulate it. It should be noted that the slider element is made up of
* <div> tags, not the html5
* <slider> element.
*
* @extends dat.controllers.Controller
* @extends dat.controllers.NumberController
*
* @param {Object} object The object to be manipulated
* @param {string} property The name of the property to be manipulated
* @param {Number} minValue Minimum allowed value
* @param {Number} maxValue Maximum allowed value
* @param {Number} stepValue Increment by which to change value
*/
class NumberControllerSlider extends NumberController {
constructor(object, property, min, max, step) {
super(object, property, { min: min, max: max, step: step });
const _this = this;
this.__background = document.createElement('div');
this.__foreground = document.createElement('div');
dom.bind(this.__background, 'mousedown', onMouseDown);
dom.bind(this.__background, 'touchstart', onTouchStart);
dom.addClass(this.__background, 'slider');
dom.addClass(this.__foreground, 'slider-fg');
function onMouseDown(e) {
document.activeElement.blur();
dom.bind(window, 'mousemove', onMouseDrag);
dom.bind(window, 'mouseup', onMouseUp);
onMouseDrag(e);
}
function onMouseDrag(e) {
e.preventDefault();
const bgRect = _this.__background.getBoundingClientRect();
_this.setValue(
map(e.clientX, bgRect.left, bgRect.right, _this.__min, _this.__max)
);
return false;
}
function onMouseUp() {
dom.unbind(window, 'mousemove', onMouseDrag);
dom.unbind(window, 'mouseup', onMouseUp);
if (_this.__onFinishChange) {
_this.__onFinishChange.call(_this, _this.getValue());
}
}
function onTouchStart(e) {
if (e.touches.length !== 1) { return; }
dom.bind(window, 'touchmove', onTouchMove);
dom.bind(window, 'touchend', onTouchEnd);
onTouchMove(e);
}
function onTouchMove(e) {
const clientX = e.touches[0].clientX;
const bgRect = _this.__background.getBoundingClientRect();
_this.setValue(
map(clientX, bgRect.left, bgRect.right, _this.__min, _this.__max)
);
}
function onTouchEnd() {
dom.unbind(window, 'touchmove', onTouchMove);
dom.unbind(window, 'touchend', onTouchEnd);
if (_this.__onFinishChange) {
_this.__onFinishChange.call(_this, _this.getValue());
}
}
this.updateDisplay();
this.__background.appendChild(this.__foreground);
this.domElement.appendChild(this.__background);
}
updateDisplay() {
const pct = (this.getValue() - this.__min) / (this.__max - this.__min);
this.__foreground.style.width = pct * 100 + '%';
return super.updateDisplay();
}
}
export default NumberControllerSlider;
================================================
FILE: src/dat/controllers/OptionController.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import Controller from './Controller';
import dom from '../dom/dom';
import common from '../utils/common';
/**
* @class Provides a select input to alter the property of an object, using a
* list of accepted values.
*
* @extends dat.controllers.Controller
*
* @param {Object} object The object to be manipulated
* @param {string} property The name of the property to be manipulated
* @param {Object|string[]} options A map of labels to acceptable values, or
* a list of acceptable string values.
*/
class OptionController extends Controller {
constructor(object, property, opts) {
super(object, property);
let options = opts;
const _this = this;
/**
* The drop down menu
* @ignore
*/
this.__select = document.createElement('select');
if (common.isArray(options)) {
const map = {};
common.each(options, function(element) {
map[element] = element;
});
options = map;
}
common.each(options, function(value, key) {
const opt = document.createElement('option');
opt.innerHTML = key;
opt.setAttribute('value', value);
_this.__select.appendChild(opt);
});
// Acknowledge original value
this.updateDisplay();
dom.bind(this.__select, 'change', function() {
const desiredValue = this.options[this.selectedIndex].value;
_this.setValue(desiredValue);
});
this.domElement.appendChild(this.__select);
}
setValue(v) {
const toReturn = super.setValue(v);
if (this.__onFinishChange) {
this.__onFinishChange.call(this, this.getValue());
}
return toReturn;
}
updateDisplay() {
if (dom.isActive(this.__select)) return this; // prevent number from updating if user is trying to manually update
this.__select.value = this.getValue();
return super.updateDisplay();
}
}
export default OptionController;
================================================
FILE: src/dat/controllers/StringController.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import Controller from './Controller';
import dom from '../dom/dom';
/**
* @class Provides a text input to alter the string property of an object.
*
* @extends dat.controllers.Controller
*
* @param {Object} object The object to be manipulated
* @param {string} property The name of the property to be manipulated
*/
class StringController extends Controller {
constructor(object, property) {
super(object, property);
const _this = this;
function onChange() {
_this.setValue(_this.__input.value);
}
function onBlur() {
if (_this.__onFinishChange) {
_this.__onFinishChange.call(_this, _this.getValue());
}
}
this.__input = document.createElement('input');
this.__input.setAttribute('type', 'text');
dom.bind(this.__input, 'keyup', onChange);
dom.bind(this.__input, 'change', onChange);
dom.bind(this.__input, 'blur', onBlur);
dom.bind(this.__input, 'keydown', function(e) {
if (e.keyCode === 13) {
this.blur();
}
});
this.updateDisplay();
this.domElement.appendChild(this.__input);
}
updateDisplay() {
// Stops the caret from moving on account of:
// keyup -> setValue -> updateDisplay
if (!dom.isActive(this.__input)) {
this.__input.value = this.getValue();
}
return super.updateDisplay();
}
}
export default StringController;
================================================
FILE: src/dat/dom/CenteredDiv.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import dom from './dom';
import common from '../utils/common';
class CenteredDiv {
constructor() {
this.backgroundElement = document.createElement('div');
common.extend(this.backgroundElement.style, {
backgroundColor: 'rgba(0,0,0,0.8)',
top: 0,
left: 0,
display: 'none',
zIndex: '1000',
opacity: 0,
WebkitTransition: 'opacity 0.2s linear',
transition: 'opacity 0.2s linear'
});
dom.makeFullscreen(this.backgroundElement);
this.backgroundElement.style.position = 'fixed';
this.domElement = document.createElement('div');
common.extend(this.domElement.style, {
position: 'fixed',
display: 'none',
zIndex: '1001',
opacity: 0,
WebkitTransition: '-webkit-transform 0.2s ease-out, opacity 0.2s linear',
transition: 'transform 0.2s ease-out, opacity 0.2s linear'
});
document.body.appendChild(this.backgroundElement);
document.body.appendChild(this.domElement);
const _this = this;
dom.bind(this.backgroundElement, 'click', function() {
_this.hide();
});
}
show() {
const _this = this;
this.backgroundElement.style.display = 'block';
this.domElement.style.display = 'block';
this.domElement.style.opacity = 0;
// this.domElement.style.top = '52%';
this.domElement.style.webkitTransform = 'scale(1.1)';
this.layout();
common.defer(function() {
_this.backgroundElement.style.opacity = 1;
_this.domElement.style.opacity = 1;
_this.domElement.style.webkitTransform = 'scale(1)';
});
}
/**
* Hide centered div
*/
hide() {
const _this = this;
const hide = function() {
_this.domElement.style.display = 'none';
_this.backgroundElement.style.display = 'none';
dom.unbind(_this.domElement, 'webkitTransitionEnd', hide);
dom.unbind(_this.domElement, 'transitionend', hide);
dom.unbind(_this.domElement, 'oTransitionEnd', hide);
};
dom.bind(this.domElement, 'webkitTransitionEnd', hide);
dom.bind(this.domElement, 'transitionend', hide);
dom.bind(this.domElement, 'oTransitionEnd', hide);
this.backgroundElement.style.opacity = 0;
// this.domElement.style.top = '48%';
this.domElement.style.opacity = 0;
this.domElement.style.webkitTransform = 'scale(1.1)';
}
layout() {
this.domElement.style.left = window.innerWidth / 2 - dom.getWidth(this.domElement) / 2 + 'px';
this.domElement.style.top = window.innerHeight / 2 - dom.getHeight(this.domElement) / 2 + 'px';
}
}
export default CenteredDiv;
================================================
FILE: src/dat/dom/dom.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import common from '../utils/common';
const EVENT_MAP = {
HTMLEvents: ['change'],
MouseEvents: ['click', 'mousemove', 'mousedown', 'mouseup', 'mouseover'],
KeyboardEvents: ['keydown']
};
const EVENT_MAP_INV = {};
common.each(EVENT_MAP, function(v, k) {
common.each(v, function(e) {
EVENT_MAP_INV[e] = k;
});
});
const CSS_VALUE_PIXELS = /(\d+(\.\d+)?)px/;
function cssValueToPixels(val) {
if (val === '0' || common.isUndefined(val)) {
return 0;
}
const match = val.match(CSS_VALUE_PIXELS);
if (!common.isNull(match)) {
return parseFloat(match[1]);
}
// TODO ...ems? %?
return 0;
}
/**
* @namespace
* @member dat.dom
*/
const dom = {
/**
*
* @param elem
* @param selectable
*/
makeSelectable: function(elem, selectable) {
if (elem === undefined || elem.style === undefined) return;
elem.onselectstart = selectable ? function() {
return false;
} : function() {
};
elem.style.MozUserSelect = selectable ? 'auto' : 'none';
elem.style.KhtmlUserSelect = selectable ? 'auto' : 'none';
elem.unselectable = selectable ? 'on' : 'off';
},
/**
*
* @param elem
* @param horizontal
* @param vert
*/
makeFullscreen: function(elem, hor, vert) {
let vertical = vert;
let horizontal = hor;
if (common.isUndefined(horizontal)) {
horizontal = true;
}
if (common.isUndefined(vertical)) {
vertical = true;
}
elem.style.position = 'absolute';
if (horizontal) {
elem.style.left = 0;
elem.style.right = 0;
}
if (vertical) {
elem.style.top = 0;
elem.style.bottom = 0;
}
},
/**
*
* @param elem
* @param eventType
* @param params
*/
fakeEvent: function(elem, eventType, pars, aux) {
const params = pars || {};
const className = EVENT_MAP_INV[eventType];
if (!className) {
throw new Error('Event type ' + eventType + ' not supported.');
}
const evt = document.createEvent(className);
switch (className) {
case 'MouseEvents':
{
const clientX = params.x || params.clientX || 0;
const clientY = params.y || params.clientY || 0;
evt.initMouseEvent(eventType, params.bubbles || false,
params.cancelable || true, window, params.clickCount || 1,
0, // screen X
0, // screen Y
clientX, // client X
clientY, // client Y
false, false, false, false, 0, null);
break;
}
case 'KeyboardEvents':
{
const init = evt.initKeyboardEvent || evt.initKeyEvent; // webkit || moz
common.defaults(params, {
cancelable: true,
ctrlKey: false,
altKey: false,
shiftKey: false,
metaKey: false,
keyCode: undefined,
charCode: undefined
});
init(eventType, params.bubbles || false,
params.cancelable, window,
params.ctrlKey, params.altKey,
params.shiftKey, params.metaKey,
params.keyCode, params.charCode);
break;
}
default:
{
evt.initEvent(eventType, params.bubbles || false, params.cancelable || true);
break;
}
}
common.defaults(evt, aux);
elem.dispatchEvent(evt);
},
/**
*
* @param elem
* @param event
* @param func
* @param bool
*/
bind: function(elem, event, func, newBool) {
const bool = newBool || false;
if (elem.addEventListener) {
elem.addEventListener(event, func, bool);
} else if (elem.attachEvent) {
elem.attachEvent('on' + event, func);
}
return dom;
},
/**
*
* @param elem
* @param event
* @param func
* @param bool
*/
unbind: function(elem, event, func, newBool) {
const bool = newBool || false;
if (elem.removeEventListener) {
elem.removeEventListener(event, func, bool);
} else if (elem.detachEvent) {
elem.detachEvent('on' + event, func);
}
return dom;
},
/**
*
* @param elem
* @param className
*/
addClass: function(elem, className) {
if (elem.className === undefined) {
elem.className = className;
} else if (elem.className !== className) {
const classes = elem.className.split(/ +/);
if (classes.indexOf(className) === -1) {
classes.push(className);
elem.className = classes.join(' ').replace(/^\s+/, '').replace(/\s+$/, '');
}
}
return dom;
},
/**
*
* @param elem
* @param className
*/
removeClass: function(elem, className) {
if (className) {
if (elem.className === className) {
elem.removeAttribute('class');
} else {
const classes = elem.className.split(/ +/);
const index = classes.indexOf(className);
if (index !== -1) {
classes.splice(index, 1);
elem.className = classes.join(' ');
}
}
} else {
elem.className = undefined;
}
return dom;
},
hasClass: function(elem, className) {
return new RegExp('(?:^|\\s+)' + className + '(?:\\s+|$)').test(elem.className) || false;
},
/**
*
* @param elem
*/
getWidth: function(elem) {
const style = getComputedStyle(elem);
return cssValueToPixels(style['border-left-width']) +
cssValueToPixels(style['border-right-width']) +
cssValueToPixels(style['padding-left']) +
cssValueToPixels(style['padding-right']) +
cssValueToPixels(style.width);
},
/**
*
* @param elem
*/
getHeight: function(elem) {
const style = getComputedStyle(elem);
return cssValueToPixels(style['border-top-width']) +
cssValueToPixels(style['border-bottom-width']) +
cssValueToPixels(style['padding-top']) +
cssValueToPixels(style['padding-bottom']) +
cssValueToPixels(style.height);
},
/**
*
* @param el
*/
getOffset: function(el) {
let elem = el;
const offset = { left: 0, top: 0 };
if (elem.offsetParent) {
do {
offset.left += elem.offsetLeft;
offset.top += elem.offsetTop;
elem = elem.offsetParent;
} while (elem);
}
return offset;
},
// http://stackoverflow.com/posts/2684561/revisions
/**
*
* @param elem
*/
isActive: function(elem) {
return elem === document.activeElement && (elem.type || elem.href);
}
};
export default dom;
================================================
FILE: src/dat/gui/GUI.js
================================================
/**
* dat-gui JavaScript Controller Library
* https://github.com/dataarts/dat.gui
*
* Copyright 2011 Data Arts Team, Google Creative Lab
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
import css from '../utils/css';
import saveDialogueContents from './saveDialogue.html';
import ControllerFactory from '../controllers/ControllerFactory';
import Controller from '../controllers/Controller';
import BooleanController from '../controllers/BooleanController';
import FunctionController from '../controllers/FunctionController';
import NumberControllerBox from '../controllers/NumberControllerBox';
import NumberControllerSlider from '../controllers/NumberControllerSlider';
import ColorController from '../controllers/ColorController';
import requestAnimationFrame from '../utils/requestAnimationFrame';
import CenteredDiv from '../dom/CenteredDiv';
import dom from '../dom/dom';
import common from '../utils/common';
import styleSheet from './style.scss'; // CSS to embed in build
css.inject(styleSheet);
/** @ignore Outer-most className for GUI's */
const CSS_NAMESPACE = 'dg';
const HIDE_KEY_CODE = 72;
/** @ignore The only value shared between the JS and SCSS. Use caution. */
const CLOSE_BUTTON_HEIGHT = 20;
const DEFAULT_DEFAULT_PRESET_NAME = 'Default';
const SUPPORTS_LOCAL_STORAGE = (function() {
try {
return !!window.localStorage;
} catch (e) {
return false;
}
}());
let SAVE_DIALOGUE;
/** @ignore Have we yet to create an autoPlace GUI? */
let autoPlaceVirgin = true;
/** @ignore Fixed position div that auto place GUI's go inside */
let autoPlaceContainer;
/** @ignore Are we hiding the GUI's ? */
let hide = false;
/** @private GUI's which should be hidden */
const hideableGuis = [];
/**
* @class A lightweight controller library for JavaScript. It allows you to easily
* manipulate variables and fire functions on the fly.
*
* @typicalname gui
*
* @example
* // Creating a GUI with options.
* var gui = new dat.GUI({name: 'My GUI'});
*
* @example
* // Creating a GUI and a subfolder.
* var gui = new dat.GUI();
* var folder1 = gui.addFolder('Flow Field');
*
* @param {Object} [params]
* @param {String} [params.name] The name of this GUI.
* @param {Object} [params.load] JSON object representing the saved state of
* this GUI.
* @param {dat.gui.GUI} [params.parent] The GUI I'm nested in.
* @param {Boolean} [params.autoPlace=true]
* @param {Boolean} [params.hideable=true] If true, GUI is shown/hidden by h keypress.
* @param {Boolean} [params.closed=false] If true, starts closed
* @param {Boolean} [params.closeOnTop=false] If true, close/open button shows on top of the GUI
*/
const GUI = function(pars) {
const _this = this;
let params = pars || {};
/**
* Outermost DOM Element
* @type {DOMElement}
*/
this.domElement = document.createElement('div');
this.__ul = document.createElement('ul');
this.domElement.appendChild(this.__ul);
dom.addClass(this.domElement, CSS_NAMESPACE);
/**
* Nested GUI's by name
* @ignore
*/
this.__folders = {};
this.__controllers = [];
/**
* List of objects I'm remembering for save, only used in top level GUI
* @ignore
*/
this.__rememberedObjects = [];
/**
* Maps the index of remembered objects to a map of controllers, only used
* in top level GUI.
*
* @private
* @ignore
*
* @example
* [
* {
* propertyName: Controller,
* anotherPropertyName: Controller
* },
* {
* propertyName: Controller
* }
* ]
*/
this.__rememberedObjectIndecesToControllers = [];
this.__listening = [];
// Default parameters
params = common.defaults(params, {
closeOnTop: false,
autoPlace: true,
width: GUI.DEFAULT_WIDTH
});
params = common.defaults(params, {
resizable: params.autoPlace,
hideable: params.autoPlace
});
if (!common.isUndefined(params.load)) {
// Explicit preset
if (params.preset) {
params.load.preset = params.preset;
}
} else {
params.load = { preset: DEFAULT_DEFAULT_PRESET_NAME };
}
if (common.isUndefined(params.parent) && params.hideable) {
hideableGuis.push(this);
}
// Only root level GUI's are resizable.
params.resizable = common.isUndefined(params.parent) && params.resizable;
if (params.autoPlace && common.isUndefined(params.scrollable)) {
params.scrollable = true;
}
// params.scrollable = common.isUndefined(params.parent) && params.scrollable === true;
// Not part of params because I don't want people passing this in via
// constructor. Should be a 'remembered' value.
let useLocalStorage =
SUPPORTS_LOCAL_STORAGE &&
localStorage.getItem(getLocalStorageHash(this, 'isLocal')) === 'true';
let saveToLocalStorage;
let titleRow;
Object.defineProperties(this,
/** @lends GUI.prototype */
{
/**
* The parent GUI
* @type dat.gui.GUI
*/
parent: {
get: function() {
return params.parent;
}
},
scrollable: {
get: function() {
return params.scrollable;
}
},
/**
* Handles GUI's element placement for you
* @type Boolean
*/
autoPlace: {
get: function() {
return params.autoPlace;
}
},
/**
* Handles GUI's position of open/close button
* @type Boolean
*/
closeOnTop: {
get: function() {
return params.closeOnTop;
}
},
/**
* The identifier for a set of saved values
* @type String
*/
preset: {
get: function() {
if (_this.parent) {
return _this.getRoot().preset;
}
return params.load.preset;
},
set: function(v) {
if (_this.parent) {
_this.getRoot().preset = v;
} else {
params.load.preset = v;
}
setPresetSelectIndex(this);
_this.revert();
}
},
/**
* The width of GUI element
* @type Number
*/
width: {
get: function() {
return params.width;
},
set: function(v) {
params.width = v;
setWidth(_this, v);
}
},
/**
* The name of GUI. Used for folders. i.e
* a folder's name
* @type String
*/
name: {
get: function() {
return params.name;
},
set: function(v) {
// TODO Check for collisions among sibling folders
params.name = v;
if (titleRow) {
titleRow.innerHTML = params.name;
}
}
},
/**
* Whether the GUI is collapsed or not
* @type Boolean
*/
closed: {
get: function() {
return params.closed;
},
set: function(v) {
params.closed = v;
if (params.closed) {
dom.addClass(_this.__ul, GUI.CLASS_CLOSED);
} else {
dom.removeClass(_this.__ul, GUI.CLASS_CLOSED);
}
// For browsers that aren't going to respect the CSS transition,
// Lets just check our height against the window height right off
// the bat.
this.onResize();
if (_this.__closeButton) {
_this.__closeButton.innerHTML = v ? GUI.TEXT_OPEN : GUI.TEXT_CLOSED;
}
}
},
/**
* Contains all presets
* @type Object
*/
load: {
get: function() {
return params.load;
}
},
/**
* Determines whether or not to use localStorage as the means for
* remembering
* @type Boolean
*/
useLocalStorage: {
get: function() {
return useLocalStorage;
},
set: function(bool) {
if (SUPPORTS_LOCAL_STORAGE) {
useLocalStorage = bool;
if (bool) {
dom.bind(window, 'unload', saveToLocalStorage);
} else {
dom.unbind(window, 'unload', saveToLocalStorage);
}
localStorage.setItem(getLocalStorageHash(_this, 'isLocal'), bool);
}
}
}
});
// Are we a root level GUI?
if (common.isUndefined(params.parent)) {
this.closed = params.closed || false;
dom.addClass(this.domElement, GUI.CLASS_MAIN);
dom.makeSelectable(this.domElement, false);
// Are we supposed to be loading locally?
if (SUPPORTS_LOCAL_STORAGE) {
if (useLocalStorage) {
_this.useLocalStorage = true;
const savedGui = localStorage.getItem(getLocalStorageHash(this, 'gui'));
if (savedGui) {
params.load = JSON.parse(savedGui);
}
}
}
this.__closeButton = document.createElement('div');
this.__closeButton.innerHTML = GUI.TEXT_CLOSED;
dom.addClass(this.__closeButton, GUI.CLASS_CLOSE_BUTTON);
if (params.closeOnTop) {
dom.addClass(this.__closeButton, GUI.CLASS_CLOSE_TOP);
this.domElement.insertBefore(this.__closeButton, this.domElement.childNodes[0]);
} else {
dom.addClass(this.__closeButton, GUI.CLASS_CLOSE_BOTTOM);
this.domElement.appendChild(this.__closeButton);
}
dom.bind(this.__closeButton, 'click', function() {
_this.closed = !_this.closed;
});
// Oh, you're a nested GUI!
} else {
if (params.closed === undefined) {
params.closed = true;
}
const titleRowName = document.createTextNode(params.name);
dom.addClass(titleRowName, 'controller-name');
titleRow = addRow(_this, titleRowName);
const onClickTitle = function(e) {
e.preventDefault();
_this.closed = !_this.closed;
return false;
};
dom.addClass(this.__ul, GUI.CLASS_CLOSED);
dom.addClass(titleRow, 'title');
dom.bind(titleRow, 'click', onClickTitle);
if (!params.closed) {
this.closed = false;
}
}
if (params.autoPlace) {
if (common.isUndefined(params.parent)) {
if (autoPlaceVirgin) {
autoPlaceContainer = document.createElement('div');
dom.addClass(autoPlaceContainer, CSS_NAMESPACE);
dom.addClass(autoPlaceContainer, GUI.CLASS_AUTO_PLACE_CONTAINER);
document.body.appendChild(autoPlaceContainer);
autoPlaceVirgin = false;
}
// Put it in the dom for you.
autoPlaceContainer.appendChild(this.domElement);
// Apply the auto styles
dom.addClass(this.domElement, GUI.CLASS_AUTO_PLACE);
}
// Make it not elastic.
if (!this.parent) {
setWidth(_this, params.width);
}
}
this.__resizeHandler = function() {
_this.onResizeDebounced();
};
dom.bind(window, 'resize', this.__resizeHandler);
dom.bind(this.__ul, 'webkitTransitionEnd', this.__resizeHandler);
dom.bind(this.__ul, 'transitionend', this.__resizeHandler);
dom.bind(this.__ul, 'oTransitionEnd', this.__resizeHandler);
this.onResize();
if (params.resizable) {
addResizeHandle(this);
}
saveToLocalStorage = function() {
if (SUPPORTS_LOCAL_STORAGE && localStorage.getItem(getLocalStorageHash(_this, 'isLocal')) === 'true') {
localStorage.setItem(getLocalStorageHash(_this, 'gui'), JSON.stringify(_this.getSaveObject()));
}
};
// expose this method publicly
this.saveToLocalStorageIfPossible = saveToLocalStorage;
function resetWidth() {
const root = _this.getRoot();
root.width += 1;
common.defer(function() {
root.width -= 1;
});
}
if (!params.parent) {
resetWidth();
}
};
GUI.toggleHide = function() {
hide = !hide;
common.each(hideableGuis, function(gui) {
gui.domElement.style.display = hide ? 'none' : '';
});
};
GUI.CLASS_AUTO_PLACE = 'a';
GUI.CLASS_AUTO_PLACE_CONTAINER = 'ac';
GUI.CLASS_MAIN = 'main';
GUI.CLASS_CONTROLLER_ROW = 'cr';
GUI.CLASS_TOO_TALL = 'taller-than-window';
GUI.CLASS_CLOSED = 'closed';
GUI.CLASS_CLOSE_BUTTON = 'close-button';
GUI.CLASS_CLOSE_TOP = 'close-top';
GUI.CLASS_CLOSE_BOTTOM = 'close-bottom';
GUI.CLASS_DRAG = 'drag';
GUI.DEFAULT_WIDTH = 245;
GUI.TEXT_CLOSED = 'Close Controls';
GUI.TEXT_OPEN = 'Open Controls';
GUI._keydownHandler = function(e) {
if (document.activeElement.type !== 'text' &&
(e.which === HIDE_KEY_CODE || e.keyCode === HIDE_KEY_CODE)) {
GUI.toggleHide();
}
};
dom.bind(window, 'keydown', GUI._keydownHandler, false);
common.extend(
GUI.prototype,
/** @lends GUI.prototype */
{
/**
* Adds a new {@link Controller} to the GUI. The type of controller created
* is inferred from the initial value of object[property]. For
* color properties, see {@link addColor}.
*
* @param {Object} object The object to be manipulated
* @param {String} property The name of the property to be manipulated
* @param {Number} [min] Minimum allowed value
* @param {Number} [max] Maximum allowed value
* @param {Number} [step] Increment by which to change value
* @returns {Controller} The controller that was added to the GUI.
* @instance
*
* @example
* // Add a string controller.
* var person = {name: 'Sam'};
* gui.add(person, 'name');
*
* @example
* // Add a number controller slider.
* var person = {age: 45};
* gui.add(person, 'age', 0, 100);
*/
add: function(object, property) {
return add(
this,
object,
property,
{
factoryArgs: Array.prototype.slice.call(arguments, 2)
}
);
},
/**
* Adds a new color controller to the GUI.
*
* @param object
* @param property
* @returns {Controller} The controller that was added to the GUI.
* @instance
*
* @example
* var palette = {
* color1: '#FF0000', // CSS string
* color2: [ 0, 128, 255 ], // RGB array
* color3: [ 0, 128, 255, 0.3 ], // RGB with alpha
* color4: { h: 350, s: 0.9, v: 0.3 } // Hue, saturation, value
* };
* gui.addColor(palette, 'color1');
* gui.addColor(palette, 'color2');
* gui.addColor(palette, 'color3');
* gui.addColor(palette, 'color4');
*/
addColor: function(object, property) {
return add(
this,
object,
property,
{
color: true
}
);
},
/**
* Removes the given controller from the GUI.
* @param {Controller} controller
* @instance
*/
remove: function(controller) {
// TODO listening?
this.__ul.removeChild(controller.__li);
this.__controllers.splice(this.__controllers.indexOf(controller), 1);
const _this = this;
common.defer(function() {
_this.onResize();
});
},
/**
* Removes the root GUI from the document and unbinds all event listeners.
* For subfolders, use `gui.removeFolder(folder)` instead.
* @instance
*/
destroy: function() {
if (this.parent) {
throw new Error(
'Only the root GUI should be removed with .destroy(). ' +
'For subfolders, use gui.removeFolder(folder) instead.'
);
}
if (this.autoPlace) {
autoPlaceContainer.removeChild(this.domElement);
}
const _this = this;
common.each(this.__folders, function(subfolder) {
_this.removeFolder(subfolder);
});
dom.unbind(window, 'keydown', GUI._keydownHandler, false);
removeListeners(this);
},
/**
* Creates a new subfolder GUI instance.
* @param name
* @returns {dat.gui.GUI} The new folder.
* @throws {Error} if this GUI already has a folder by the specified
* name
* @instance
*/
addFolder: function(name) {
// We have to prevent collisions on names in order to have a key
// by which to remember saved values
if (this.__folders[name] !== undefined) {
throw new Error('You already have a folder in this GUI by the' +
' name "' + name + '"');
}
const newGuiParams = { name: name, parent: this };
// We need to pass down the autoPlace trait so that we can
// attach event listeners to open/close folder actions to
// ensure that a scrollbar appears if the window is too short.
newGuiParams.autoPlace = this.autoPlace;
// Do we have saved appearance data for this folder?
if (this.load && // Anything loaded?
this.load.folders && // Was my parent a dead-end?
this.load.folders[name]) { // Did daddy remember me?
// Start me closed if I was closed
newGuiParams.closed = this.load.folders[name].closed;
// Pass down the loaded data
newGuiParams.load = this.load.folders[name];
}
const gui = new GUI(newGuiParams);
this.__folders[name] = gui;
const li = addRow(this, gui.domElement);
dom.addClass(li, 'folder');
return gui;
},
/**
* Removes a subfolder GUI instance.
* @param {dat.gui.GUI} folder The folder to remove.
* @instance
*/
removeFolder: function(folder) {
this.__ul.removeChild(folder.domElement.parentElement);
delete this.__folders[folder.name];
// Do we have saved appearance data for this folder?
if (this.load && // Anything loaded?
this.load.folders && // Was my parent a dead-end?
this.load.folders[folder.name]) {
delete this.load.folders[folder.name];
}
removeListeners(folder);
const _this = this;
common.each(folder.__folders, function(subfolder) {
folder.removeFolder(subfolder);
});
common.defer(function() {
_this.onResize();
});
},
/**
* Opens the GUI.
*/
open: function() {
this.closed = false;
},
/**
* Closes the GUI.
*/
close: function() {
this.closed = true;
},
/**
* Hides the GUI.
*/
hide: function() {
this.domElement.style.display = 'none';
},
/**
* Shows the GUI.
*/
show: function() {
this.domElement.style.display = '';
},
onResize: function() {
// we debounce this function to prevent performance issues when rotating on tablet/mobile
const root = this.getRoot();
if (root.scrollable) {
const top = dom.getOffset(root.__ul).top;
let h = 0;
common.each(root.__ul.childNodes, function(node) {
if (!(root.autoPlace && node === root.__save_row)) {
h += dom.getHeight(node);
}
});
if (window.innerHeight - top - CLOSE_BUTTON_HEIGHT < h) {
dom.addClass(root.domElement, GUI.CLASS_TOO_TALL);
root.__ul.style.height = window.innerHeight - top - CLOSE_BUTTON_HEIGHT + 'px';
} else {
dom.removeClass(root.domElement, GUI.CLASS_TOO_TALL);
root.__ul.style.height = 'auto';
}
}
if (root.__resize_handle) {
common.defer(function() {
root.__resize_handle.style.height = root.__ul.offsetHeight + 'px';
});
}
if (root.__closeButton) {
root.__closeButton.style.width = root.width + 'px';
}
},
onResizeDebounced: common.debounce(function() { this.onResize(); }, 50),
/**
* Mark objects for saving. The order of these objects cannot change as
* the GUI grows. When remembering new objects, append them to the end
* of the list.
*
* @param {...Object} objects
* @throws {Error} if not called on a top level GUI.
* @instance
* @ignore
*/
remember: function() {
if (common.isUndefined(SAVE_DIALOGUE)) {
SAVE_DIALOGUE = new CenteredDiv();
SAVE_DIALOGUE.domElement.innerHTML = saveDialogueContents;
}
if (this.parent) {
throw new Error('You can only call remember on a top level GUI.');
}
const _this = this;
common.each(Array.prototype.slice.call(arguments), function(object) {
if (_this.__rememberedObjects.length === 0) {
addSaveMenu(_this);
}
if (_this.__rememberedObjects.indexOf(object) === -1) {
_this.__rememberedObjects.push(object);
}
});
if (this.autoPlace) {
// Set save row width
setWidth(this, this.width);
}
},
/**
* @returns {dat.gui.GUI} the topmost parent GUI of a nested GUI.
* @instance
*/
getRoot: function() {
let gui = this;
while (gui.parent) {
gui = gui.parent;
}
return gui;
},
/**
* @returns {Object} a JSON object representing the current state of
* this GUI as well as its remembered properties.
* @instance
*/
getSaveObject: function() {
const toReturn = this.load;
toReturn.closed = this.closed;
// Am I remembering any values?
if (this.__rememberedObjects.length > 0) {
toReturn.preset = this.preset;
if (!toReturn.remembered) {
toReturn.remembered = {};
}
toReturn.remembered[this.preset] = getCurrentPreset(this);
}
toReturn.folders = {};
common.each(this.__folders, function(element, key) {
toReturn.folders[key] = element.getSaveObject();
});
return toReturn;
},
save: function() {
if (!this.load.remembered) {
this.load.remembered = {};
}
this.load.remembered[this.preset] = getCurrentPreset(this);
markPresetModified(this, false);
this.saveToLocalStorageIfPossible();
},
saveAs: function(presetName) {
if (!this.load.remembered) {
// Retain default values upon first save
this.load.remembered = {};
this.load.remembered[DEFAULT_DEFAULT_PRESET_NAME] = getCurrentPreset(this, true);
}
this.load.remembered[presetName] = getCurrentPreset(this);
this.preset = presetName;
addPresetOption(this, presetName, true);
this.saveToLocalStorageIfPossible();
},
revert: function(gui) {
common.each(this.__controllers, function(controller) {
// Make revert work on Default.
if (!this.getRoot().load.remembered) {
controller.setValue(controller.initialValue);
} else {
recallSavedValue(gui || this.getRoot(), controller);
}
// fire onFinishChange callback
if (controller.__onFinishChange) {
controller.__onFinishChange.call(controller, controller.getValue());
}
}, this);
common.each(this.__folders, function(folder) {
folder.revert(folder);
});
if (!gui) {
markPresetModified(this.getRoot(), false);
}
},
listen: function(controller) {
const init = this.__listening.length === 0;
this.__listening.push(controller);
if (init) {
updateDisplays(this.__listening);
}
},
updateDisplay: function() {
common.each(this.__controllers, function(controller) {
controller.updateDisplay();
});
common.each(this.__folders, function(folder) {
folder.updateDisplay();
});
}
}
);
/**
* Add a row to the end of the GUI or before another row.
*
* @param gui
* @param [newDom] If specified, inserts the dom content in the new row
* @param [liBefore] If specified, places the new row before another row
*
* @ignore
*/
function addRow(gui, newDom, liBefore) {
const li = document.createElement('li');
if (newDom) {
li.appendChild(newDom);
}
if (liBefore) {
gui.__ul.insertBefore(li, liBefore);
} else {
gui.__ul.appendChild(li);
}
gui.onResize();
return li;
}
function removeListeners(gui) {
dom.unbind(window, 'resize', gui.__resizeHandler);
if (gui.saveToLocalStorageIfPossible) {
dom.unbind(window, 'unload', gui.saveToLocalStorageIfPossible);
}
}
function markPresetModified(gui, modified) {
const opt = gui.__preset_select[gui.__preset_select.selectedIndex];
if (modified) {
opt.innerHTML = opt.value + '*';
} else {
opt.innerHTML = opt.value;
}
}
function augmentController(gui, li, controller) {
controller.__li = li;
controller.__gui = gui;
common.extend(controller, /** @lends Controller.prototype */ {
/**
* @param {Array|Object} options
* @return {Controller}
*/
options: function(options) {
if (arguments.length > 1) {
const nextSibling = controller.__li.nextElementSibling;
controller.remove();
return add(
gui,
controller.object,
controller.property,
{
before: nextSibling,
factoryArgs: [common.toArray(arguments)]
}
);
}
if (common.isArray(options) || common.isObject(options)) {
const nextSibling = controller.__li.nextElementSibling;
controller.remove();
return add(
gui,
controller.object,
controller.property,
{
before: nextSibling,
factoryArgs: [options]
}
);
}
},
/**
* Sets the name of the controller.
* @param {string} name
* @return {Controller}
*/
name: function(name) {
controller.__li.firstElementChild.firstElementChild.innerHTML = name;
return controller;
},
/**
* Sets controller to listen for changes on its underlying object.
* @return {Controller}
*/
listen: function() {
controller.__gui.listen(controller);
return controller;
},
/**
* Removes the controller from its parent GUI.
* @return {Controller}
*/
remove: function() {
controller.__gui.remove(controller);
return controller;
}
});
// All sliders should be accompanied by a box.
if (controller instanceof NumberControllerSlider) {
const box = new NumberControllerBox(controller.object, controller.property,
{ min: controller.__min, max: controller.__max, step: controller.__step });
common.each(['updateDisplay', 'onChange', 'onFinishChange', 'step', 'min', 'max'], function(method) {
const pc = controller[method];
const pb = box[method];
controller[method] = box[method] = function() {
const args = Array.prototype.slice.call(arguments);
pb.apply(box, args);
return pc.apply(controller, args);
};
});
dom.addClass(li, 'has-slider');
controller.domElement.insertBefore(box.domElement, controller.domElement.firstElementChild);
} else if (controller instanceof NumberControllerBox) {
const r = function(returned) {
// Have we defined both boundaries?
if (common.isNumber(controller.__min) && common.isNumber(controller.__max)) {
// Well, then lets just replace this with a slider.
// lets remember if the old controller had a specific name or was listening
const oldName = controller.__li.firstElementChild.firstElementChild.innerHTML;
const wasListening = controller.__gui.__listening.indexOf(controller) > -1;
controller.remove();
const newController = add(
gui,
controller.object,
controller.property,
{
before: controller.__li.nextElementSibling,
factoryArgs: [controller.__min, controller.__max, controller.__step]
}
);
newController.name(oldName);
if (wasListening) newController.listen();
return newController;
}
return returned;
};
controller.min = common.compose(r, controller.min);
controller.max = common.compose(r, controller.max);
} else if (controller instanceof BooleanController) {
dom.bind(li, 'click', function() {
dom.fakeEvent(controller.__checkbox, 'click');
});
dom.bind(controller.__checkbox, 'click', function(e) {
e.stopPropagation(); // Prevents double-toggle
});
} else if (controller instanceof FunctionController) {
dom.bind(li, 'click', function() {
dom.fakeEvent(controller.__button, 'click');
});
dom.bind(li, 'mouseover', function() {
dom.addClass(controller.__button, 'hover');
});
dom.bind(li, 'mouseout', function() {
dom.removeClass(controller.__button, 'hover');
});
} else if (controller instanceof ColorController) {
dom.addClass(li, 'color');
controller.updateDisplay = common.compose(function(val) {
li.style.borderLeftColor = controller.__color.toString();
return val;
}, controller.updateDisplay);
controller.updateDisplay();
}
controller.setValue = common.compose(function(val) {
if (gui.getRoot().__preset_select && controller.isModified()) {
markPresetModified(gui.getRoot(), true);
}
return val;
}, controller.setValue);
}
function recallSavedValue(gui, controller) {
// Find the topmost GUI, that's where remembered objects live.
const root = gui.getRoot();
// Does the object we're controlling match anything we've been told to
// remember?
const matchedIndex = root.__rememberedObjects.indexOf(controller.object);
// Why yes, it does!
if (matchedIndex !== -1) {
// Let me fetch a map of controllers for thcommon.isObject.
let controllerMap = root.__rememberedObjectIndecesToControllers[matchedIndex];
// Ohp, I believe this is the first controller we've created for this
// object. Lets make the map fresh.
if (controllerMap === undefined) {
controllerMap = {};
root.__rememberedObjectIndecesToControllers[matchedIndex] =
controllerMap;
}
// Keep track of this controller
controllerMap[controller.property] = controller;
// Okay, now have we saved any values for this controller?
if (root.load && root.load.remembered) {
const presetMap = root.load.remembered;
// Which preset are we trying to load?
let preset;
if (presetMap[gui.preset]) {
preset = presetMap[gui.preset];
} else if (presetMap[DEFAULT_DEFAULT_PRESET_NAME]) {
// Uhh, you can have the default instead?
preset = presetMap[DEFAULT_DEFAULT_PRESET_NAME];
} else {
// Nada.
return;
}
// Did the loaded object remember thcommon.isObject? && Did we remember this particular property?
if (preset[matchedIndex] && preset[matchedIndex][controller.property] !== undefined) {
// We did remember something for this guy ...
const value = preset[matchedIndex][controller.property];
// And that's what it is.
controller.initialValue = value;
controller.setValue(value);
}
}
}
}
function add(gui, object, property, params) {
if (object[property] === undefined) {
throw new Error(`Object "${object}" has no property "${property}"`);
}
let controller;
if (params.color) {
controller = new ColorController(object, property);
} else {
const factoryArgs = [object, property].concat(params.factoryArgs);
controller = ControllerFactory.apply(gui, factoryArgs);
}
if (params.before instanceof Controller) {
params.before = params.before.__li;
}
recallSavedValue(gui, controller);
dom.addClass(controller.domElement, 'c');
const name = document.createElement('span');
dom.addClass(name, 'property-name');
name.innerHTML = controller.property;
const container = document.createElement('div');
container.appendChild(name);
container.appendChild(controller.domElement);
const li = addRow(gui, container, params.before);
dom.addClass(li, GUI.CLASS_CONTROLLER_ROW);
if (controller instanceof ColorController) {
dom.addClass(li, 'color');
} else {
dom.addClass(li, typeof controller.getValue());
}
augmentController(gui, li, controller);
gui.__controllers.push(controller);
return controller;
}
function getLocalStorageHash(gui, key) {
// TODO how does this deal with multiple GUI's?
return document.location.href + '.' + key;
}
function addPresetOption(gui, name, setSelected) {
const opt = document.createElement('option');
opt.innerHTML = name;
opt.value = name;
gui.__preset_select.appendChild(opt);
if (setSelected) {
gui.__preset_select.selectedIndex = gui.__preset_select.length - 1;
}
}
function showHideExplain(gui, explain) {
explain.style.display = gui.useLocalStorage ? 'block' : 'none';
}
function addSaveMenu(gui) {
const div = gui.__save_row = document.createElement('li');
dom.addClass(gui.domElement, 'has-save');
gui.__ul.insertBefore(div, gui.__ul.firstChild);
dom.addClass(div, 'save-row');
const gears = document.createElement('span');
gears.innerHTML = ' ';
dom.addClass(gears, 'button gears');
// TODO replace with FunctionController
const button = document.createElement('span');
button.innerHTML = 'Save';
dom.addClass(button, 'button');
dom.addClass(button, 'save');
const button2 = document.createElement('span');
button2.innerHTML = 'New';
dom.addClass(button2, 'button');
dom.addClass(button2, 'save-as');
const button3 = document.createElement('span');
button3.innerHTML = 'Revert';
dom.addClass(button3, 'button');
dom.addClass(button3, 'revert');
const select = gui.__preset_select = document.createElement('select');
if (gui.load && gui.load.remembered) {
common.each(gui.load.remembered, function(value, key) {
addPresetOption(gui, key, key === gui.preset);
});
} else {
addPresetOption(gui, DEFAULT_DEFAULT_PRESET_NAME, false);
}
dom.bind(select, 'change', function() {
for (let index = 0; index < gui.__preset_select.length; index++) {
gui.__preset_select[index].innerHTML = gui.__preset_select[index].value;
}
gui.preset = this.value;
});
div.appendChild(select);
div.appendChild(gears);
div.appendChild(button);
div.appendChild(button2);
div.appendChild(button3);
if (SUPPORTS_LOCAL_STORAGE) {
const explain = document.getElementById('dg-local-explain');
const localStorageCheckBox = document.getElementById('dg-local-storage');
const saveLocally = document.getElementById('dg-save-locally');
saveLocally.style.display = 'block';
if (localStorage.getItem(getLocalStorageHash(gui, 'isLocal')) === 'true') {
localStorageCheckBox.setAttribute('checked', 'checked');
}
showHideExplain(gui, explain);
// TODO: Use a boolean controller, fool!
dom.bind(localStorageCheckBox, 'change', function() {
gui.useLocalStorage = !gui.useLocalStorage;
showHideExplain(gui, explain);
});
}
const newConstructorTextArea = document.getElementById('dg-new-constructor');
dom.bind(newConstructorTextArea, 'keydown', function(e) {
if (e.metaKey && (e.which === 67 || e.keyCode === 67)) {
SAVE_DIALOGUE.hide();
}
});
dom.bind(gears, 'click', function() {
newConstructorTextArea.innerHTML = JSON.stringify(gui.getSaveObject(), undefined, 2);
SAVE_DIALOGUE.show();
newConstructorTextArea.focus();
newConstructorTextArea.select();
});
dom.bind(button, 'click', function() {
gui.save();
});
dom.bind(button2, 'click', function() {
const presetName = prompt('Enter a new preset name.');
if (presetName) {
gui.saveAs(presetName);
}
});
dom.bind(button3, 'click', function() {
gui.revert();
});
// div.appendChild(button2);
}
function addResizeHandle(gui) {
let pmouseX;
gui.__resize_handle = document.createElement('div');
common.extend(gui.__resize_handle.style, {
width: '6px',
marginLeft: '-3px',
height: '200px',
cursor: 'ew-resize',
position: 'absolute'
// border: '1px solid blue'
});
function drag(e) {
e.preventDefault();
gui.width += pmouseX - e.clientX;
gui.onResize();
pmouseX = e.clientX;
return false;
}
function dragStop() {
dom.removeClass(gui.__closeButton, GUI.CLASS_DRAG);
dom.unbind(window, 'mousemove', drag);
dom.unbind(window, 'mouseup', dragStop);
}
function dragStart(e) {
e.preventDefault();
pmouseX = e.clientX;
dom.addClass(gui.__closeButton, GUI.CLASS_DRAG);
dom.bind(window, 'mousemove', drag);
dom.bind(window, 'mouseup', dragStop);
return false;
}
dom.bind(gui.__resize_handle, 'mousedown', dragStart);
dom.bind(gui.__closeButton, 'mousedown', dragStart);
gui.domElement.insertBefore(gui.__resize_handle, gui.domElement.firstElementChild);
}
function setWidth(gui, w) {
gui.domElement.style.width = w + 'px';
// Auto placed save-rows are position fixed, so we have to
// set the width manually if we want it to bleed to the edge
if (gui.__save_row && gui.autoPlace) {
gui.__save_row.style.width = w + 'px';
}
if (gui.__closeButton) {
gui.__closeButton.style.width = w + 'px';
}
}
function getCurrentPreset(gui, useInitialValues) {
const toReturn = {};
// For each object I'm remembering
common.each(gui.__rememberedObjects, function(val, index) {
const savedValues = {};
// The controllers I've made for thcommon.isObject by property
const controllerMap =
gui.__rememberedObjectIndecesToControllers[index];
// Remember each value for each property
common.each(controllerMap, function(controller, property) {
savedValues[property] = useInitialValues ? controller.initialValue : controller.getValue();
});
// Save the values for thcommon.isObject
toReturn[index] = savedValues;
});
return toReturn;
}
function setPresetSelectIndex(gui) {
for (let index = 0; index < gui.__preset_select.length; index++) {
if (gui.__preset_select[index].value === gui.preset) {
gui.__preset_select.selectedIndex = index;
}
}
}
function updateDisplays(controllerArray) {
if (controllerArray.length !== 0) {
requestAnimationFrame.call(window, function() {
updateDisplays(controllerArray);
});
}
common.each(controllerArray, function(c) {
c.updateDisplay();
});
}
export default GUI;
================================================
FILE: src/dat/gui/_structure.scss
================================================
$nest-margin: 4px;
$row-height: 27px;
$button-height: 20px;
.dg {
/** Clear list styles */
ul {
list-style: none;
margin: 0;
padding: 0;
width: 100%;
clear: both;
}
/* Auto-place container */
&.ac {
position: fixed;
top: 0;
left: 0;
right: 0;
height: 0;
z-index: 0;
}
&:not(.ac) .main {
/** Exclude mains in ac so that we don't hide close button */
overflow: hidden;
}
&.main {
@include transition(opacity, 0.1s, linear);
&.taller-than-window {
overflow-y: auto;
.close-button {
opacity: 1;
/* TODO, these are style notes */
margin-top: -1px;
border-top: 1px solid $border-color;
}
}
ul.closed .close-button {
opacity: 1 !important;
}
&:hover .close-button,
.close-button.drag {
opacity: 1;
}
.close-button {
/*opacity: 0;*/
@include transition(opacity, 0.1s, linear);
border: 0;
line-height: $button-height - 1;
height: $button-height;
/* TODO, these are style notes */
cursor: pointer;
text-align: center;
background-color: #000;
&.close-top {
position: relative;
}
&.close-bottom {
position: absolute;
}
&:hover {
background-color: #111;
}
}
}
/* Auto-placed GUI's */
&.a {
float: right;
margin-right: 15px;
overflow-y:visible;
&.has-save > ul {
&.close-top {
margin-top: 0;
}
&.close-bottom {
margin-top: $row-height;
}
&.closed {
margin-top: 0;
}
}
.save-row {
top: 0;
z-index: 1002;
&.close-top {
position: relative;
}
&.close-bottom {
position: fixed;
}
}
}
li {
@include transition(height, 0.1s, ease-out);
@include transition(overflow, 0.1s, linear);
}
/* Line items that don't contain folders. */
li:not(.folder) {
cursor: auto;
height: $row-height;
line-height: $row-height;
padding: 0 4px 0 5px;
}
li.folder {
padding: 0;
border-left: $nest-margin solid rgba(0, 0, 0, 0);
}
/** Folder names */
li.title {
cursor: pointer;
margin-left: -$nest-margin;
}
/** Hides closed items */
.closed li:not(.title),
.closed ul li,
.closed ul li > * {
height: 0;
overflow: hidden;
border: 0;
}
/** Controller row */
.cr {
clear: both;
padding-left: 3px;
height: $row-height;
overflow: hidden;
}
/** Name-half (left) */
.property-name {
cursor: default;
float: left;
clear: left;
width: 40%;
overflow: hidden;
text-overflow: ellipsis;
}
/** Function controllers can use the entire width */
.cr.function .property-name {
width: 100%;
}
/** Controller-half (right) */
.c {
float: left;
width: 60%;
position: relative;
}
/** Controller placement */
.c input[type=text] {
border: 0;
margin-top: 4px;
padding: 3px;
width: 100%;
float: right;
}
/** Shorter number boxes when slider is present. */
.has-slider input[type=text] {
width: 30%;
/*display: none;*/
margin-left: 0;
}
.slider {
float: left;
width: 66%;
margin-left: -5px;
margin-right: 0;
height: 19px;
margin-top: 4px;
}
.slider-fg {
height: 100%;
}
.c input[type=checkbox] {
margin-top: 7px;
}
.c select {
margin-top: 5px;
}
/** Ensure the entire boolean and function row shows a hand */
.cr.function,
.cr.function .property-name, /* Don't know why I need to be this explicit */
.cr.function *,
.cr.boolean,
.cr.boolean * {
cursor: pointer;
}
/** allow overflow for color selector */
.cr.color {
overflow: visible;
}
.selector {
display: none;
position: absolute;
margin-left: -9px;
margin-top: 23px;
z-index: 10;
}
.c:hover .selector,
.selector.drag {
display: block;
}
li.save-row {
padding: 0;
.button {
display: inline-block;
padding: 0px 6px;
}
}
&.dialogue {
background-color: #222;
width: 460px;
padding: 15px;
font-size: 13px;
line-height: 15px;
}
}
/* TODO Separate style and structure */
#dg-new-constructor {
padding: 10px;
color: #222;
font-family: Monaco, monospace;
font-size: 10px;
border: 0;
resize: none;
box-shadow: inset 1px 1px 1px #888;
word-wrap: break-word;
margin: 12px 0;
display: block;
width: 440px;
overflow-y: scroll;
height: 100px;
position: relative;
}
#dg-local-explain {
display: none;
font-size: 11px;
line-height: 17px;
border-radius: 3px;
background-color: #333;
padding: 8px;
margin-top: 10px;
code {
font-size: 10px;
}
}
#dat-gui-save-locally {
display: none;
}
================================================
FILE: src/dat/gui/saveDialogue.html.js
================================================
const saveDialogContents = `GUI's constructor:
localStorage on exit.
localStorage will
override those passed to dat.GUI's constructor. This makes it
easier to work incrementally, but localStorage is fragile,
and your friends may not see the same values you do.
| t |