Added button to maximise the output window

.gitignore

@@ -4,3 +4,4 @@ build/dev
 docs/*
 !docs/*.conf.json
 !docs/*.ico
+.vscode

src/html/index.html

@@ -117,6 +117,7 @@
                                 <button type="button" class="btn btn-default btn-sm" id="save-to-file"><img src="images/save_as-16x16.png" /> Save to file</button>
                                 <button type="button" class="btn btn-default btn-sm" id="switch"><img src="images/switch-16x16.png" /> Move output to input</button>
                                 <button type="button" class="btn btn-default btn-sm" id="undo-switch" disabled="disabled"><img src="images/undo-16x16.png" /> Undo</button>
+                                <button type="button" class="btn btn-default btn-sm" id="maximise-output"><img src="images/maximise-16x16.png" /> Max</button>
                             </div>
                             <div class="io-info" id="output-info"></div>
                             <div class="io-info" id="output-selection-info"></div>

src/js/lib/split.js

@@ -1,6 +1,6 @@
 /** @license
 ========================================================================
-  Split.js v1.0.7
+  Split.js v1.1.1
   Copyright (c) 2015 Nathan Cahill
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -22,17 +22,43 @@
   THE SOFTWARE.
 */
 
+
+// The programming goals of Split.js are to deliver readable, understandable and
+// maintainable code, while at the same time manually optimizing for tiny minified file size,
+// browser compatibility without additional requirements, graceful fallback (IE8 is supported)
+// and very few assumptions about the user's page layout.
+//
+// Make sure all browsers handle this JS library correctly with ES5.
+// More information here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
 'use strict';
 
+// A wrapper function that does a couple things:
+//
+// 1. Doesn't pollute the global namespace. This is important for a library.
+// 2. Allows us to mount the library in different module systems, as well as
+//    directly in the browser.
 (function() {
 
+// Save the global `this` for use later. In this case, since the library only
+// runs in the browser, it will refer to `window`. Also, figure out if we're in IE8
+// or not. IE8 will still render correctly, but will be static instead of draggable.
+//
+// Save a couple long function names that are used frequently.
+// This optimization saves around 400 bytes.
 var global = this
+  , isIE8 = global.attachEvent && !global[addEventListener]
+  , document = global.document
   , addEventListener = 'addEventListener'
   , removeEventListener = 'removeEventListener'
   , getBoundingClientRect = 'getBoundingClientRect'
-  , isIE8 = global.attachEvent && !global[addEventListener]
-  , document = global.document
 
+  // This library only needs two helper functions:
+  //
+  // The first determines which prefixes of CSS calc we need.
+  // We only need to do this once on startup, when this anonymous function is called.
+  // 
+  // Tests -webkit, -moz and -o prefixes. Modified from StackOverflow:
+  // http://stackoverflow.com/questions/16625140/js-feature-detection-to-detect-the-usage-of-webkit-calc-over-calc/16625167#16625167
   , calc = (function () {
         var el
           , prefixes = ["", "-webkit-", "-moz-", "-o-"]
@@ -46,6 +72,10 @@ var global = this
             }
         }
     })()
+
+  // The second helper function allows elements and string selectors to be used
+  // interchangeably. In either case an element is returned. This allows us to
+  // do `Split(elem1, elem2)` as well as `Split('#id1', '#id2')`.
   , elementOrSelector = function (el) {
         if (typeof el === 'string' || el instanceof String) {
             return document.querySelector(el)
@@ -54,6 +84,38 @@ var global = this
         }
     }
 
+  // The main function to initialize a split. Split.js thinks about each pair
+  // of elements as an independant pair. Dragging the gutter between two elements
+  // only changes the dimensions of elements in that pair. This is key to understanding
+  // how the following functions operate, since each function is bound to a pair.
+  // 
+  // A pair object is shaped like this:
+  // 
+  // {
+  //     a: DOM element,
+  //     b: DOM element,
+  //     aMin: Number,
+  //     bMin: Number,
+  //     dragging: Boolean,
+  //     parent: DOM element,
+  //     isFirst: Boolean,
+  //     isLast: Boolean,
+  //     direction: 'horizontal' | 'vertical'
+  // }
+  //
+  // The basic sequence:
+  // 
+  // 1. Set defaults to something sane. `options` doesn't have to be passed at all.
+  // 2. Initialize a bunch of strings based on the direction we're splitting.
+  //    A lot of the behavior in the rest of the library is paramatized down to
+  //    rely on CSS strings and classes.
+  // 3. Define the dragging helper functions, and a few helpers to go with them.
+  // 4. Define a few more functions that "balance" the entire split instance.
+  //    Split.js tries it's best to cope with min sizes that don't add up.
+  // 5. Loop through the elements while pairing them off. Every pair gets an
+  //    `pair` object, a gutter, and special isFirst/isLast properties.
+  // 6. Actually size the pair elements, insert gutters and attach event listeners.
+  // 7. Balance all of the pairs to accomodate min sizes as best as possible.
   , Split = function (ids, options) {
     var dimension
       , i
@@ -65,8 +127,9 @@ var global = this
       , paddingB
       , pairs = []
 
-    // Set defaults
+    // 1. Set defaults to something sane. `options` doesn't have to be passed at all,
-
+    // so create an options object if none exists. Pixel values 10, 100 and 30 are
+    // arbitrary but feel natural.
     options = typeof options !== 'undefined' ?  options : {}
 
     if (typeof options.gutterSize === 'undefined') options.gutterSize = 10
@@ -74,6 +137,9 @@ var global = this
     if (typeof options.snapOffset === 'undefined') options.snapOffset = 30
     if (typeof options.direction === 'undefined') options.direction = 'horizontal'
 
+    // 2. Initialize a bunch of strings based on the direction we're splitting.
+    // A lot of the behavior in the rest of the library is paramatized down to
+    // rely on CSS strings and classes.
     if (options.direction == 'horizontal') {
         dimension = 'width'
         clientDimension = 'clientWidth'
@@ -94,25 +160,43 @@ var global = this
         if (!options.cursor) options.cursor = 'ns-resize'
     }
 
-    // Event listeners for drag events, bound to a pair object.
+    // 3. Define the dragging helper functions, and a few helpers to go with them.
-    // Calculate the pair's position and size when dragging starts.
+    // Each helper is bound to a pair object that contains it's metadata. This
-    // Prevent selection on start and re-enable it when done.
+    // also makes it easy to store references to listeners that that will be
-
+    // added and removed.
+    // 
+    // Even though there are no other functions contained in them, aliasing
+    // this to self saves 50 bytes or so since it's used so frequently.
+    //
+    // The pair object saves metadata like dragging state, position and
+    // event listener references.
+    //
+    // startDragging calls `calculateSizes` to store the inital size in the pair object.
+    // It also adds event listeners for mouse/touch events,
+    // and prevents selection while dragging so avoid the selecting text.
     var startDragging = function (e) {
+            // Alias frequently used variables to save space. 200 bytes.
             var self = this
               , a = self.a
               , b = self.b
 
+            // Call the onDragStart callback.
             if (!self.dragging && options.onDragStart) {
                 options.onDragStart()
             }
 
+            // Don't actually drag the element. We emulate that in the drag function.
             e.preventDefault()
 
+            // Set the dragging property of the pair object.
             self.dragging = true
+
+            // Create two event listeners bound to the same pair object and store
+            // them in the pair object.
             self.move = drag.bind(self)
             self.stop = stopDragging.bind(self)
 
+            // All the binding. `window` gets the stop events in case we drag out of the elements.
             global[addEventListener]('mouseup', self.stop)
             global[addEventListener]('touchend', self.stop)
             global[addEventListener]('touchcancel', self.stop)
@@ -120,10 +204,11 @@ var global = this
             self.parent[addEventListener]('mousemove', self.move)
             self.parent[addEventListener]('touchmove', self.move)
 
-            a[addEventListener]('selectstart', preventSelection)
+            // Disable selection. Disable!
-            a[addEventListener]('dragstart', preventSelection)
+            a[addEventListener]('selectstart', noop)
-            b[addEventListener]('selectstart', preventSelection)
+            a[addEventListener]('dragstart', noop)
-            b[addEventListener]('dragstart', preventSelection)
+            b[addEventListener]('selectstart', noop)
+            b[addEventListener]('dragstart', noop)
 
             a.style.userSelect = 'none'
             a.style.webkitUserSelect = 'none'
@@ -135,11 +220,16 @@ var global = this
             b.style.MozUserSelect = 'none'
             b.style.pointerEvents = 'none'
 
+            // Set the cursor, both on the gutter and the parent element.
+            // Doing only a, b and gutter causes flickering.
             self.gutter.style.cursor = options.cursor
             self.parent.style.cursor = options.cursor
 
+            // Cache the initial sizes of the pair.
             calculateSizes.call(self)
         }
+
+      // stopDragging is very similar to startDragging in reverse.
       , stopDragging = function () {
             var self = this
               , a = self.a
@@ -151,6 +241,7 @@ var global = this
 
             self.dragging = false
 
+            // Remove the stored event listeners. This is why we store them.
             global[removeEventListener]('mouseup', self.stop)
             global[removeEventListener]('touchend', self.stop)
             global[removeEventListener]('touchcancel', self.stop)
@@ -158,13 +249,15 @@ var global = this
             self.parent[removeEventListener]('mousemove', self.move)
             self.parent[removeEventListener]('touchmove', self.move)
 
+            // Delete them once they are removed. I think this makes a difference
+            // in memory usage with a lot of splits on one page. But I don't know for sure.
             delete self.stop
             delete self.move
 
-            a[removeEventListener]('selectstart', preventSelection)
+            a[removeEventListener]('selectstart', noop)
-            a[removeEventListener]('dragstart', preventSelection)
+            a[removeEventListener]('dragstart', noop)
-            b[removeEventListener]('selectstart', preventSelection)
+            b[removeEventListener]('selectstart', noop)
-            b[removeEventListener]('dragstart', preventSelection)
+            b[removeEventListener]('dragstart', noop)
 
             a.style.userSelect = ''
             a.style.webkitUserSelect = ''
@@ -179,36 +272,70 @@ var global = this
             self.gutter.style.cursor = ''
             self.parent.style.cursor = ''
         }
+
+      // drag, where all the magic happens. The logic is really quite simple:
+      // 
+      // 1. Ignore if the pair is not dragging.
+      // 2. Get the offset of the event.
+      // 3. Snap offset to min if within snappable range (within min + snapOffset).
+      // 4. Actually adjust each element in the pair to offset.
+      // 
+      // ---------------------------------------------------------------------
+      // |    | <- this.aMin               ||              this.bMin -> |    |
+      // |    |  | <- this.snapOffset      ||     this.snapOffset -> |  |    |
+      // |    |  |                         ||                        |  |    |
+      // |    |  |                         ||                        |  |    |
+      // ---------------------------------------------------------------------
+      // | <- this.start                                        this.size -> |
       , drag = function (e) {
             var offset
 
             if (!this.dragging) return
 
-            // Get the relative position of the event from the first side of the
+            // Get the offset of the event from the first side of the
-            // pair.
+            // pair `this.start`. Supports touch events, but not multitouch, so only the first
-
+            // finger `touches[0]` is counted.
             if ('touches' in e) {
                 offset = e.touches[0][clientAxis] - this.start
             } else {
                 offset = e[clientAxis] - this.start
             }
 
-            // If within snapOffset of min or max, set offset to min or max
+            // If within snapOffset of min or max, set offset to min or max.
-
+            // snapOffset buffers aMin and bMin, so logic is opposite for both.
-            if (offset <=  this.aMin + options.snapOffset) {
+            // Include the appropriate gutter sizes to prevent overflows.
-                offset = this.aMin
+            if (offset <= this.aMin + options.snapOffset + this.aGutterSize) {
-            } else if (offset >= this.size - this.bMin - options.snapOffset) {
+                offset = this.aMin + this.aGutterSize
-                offset = this.size - this.bMin
+            } else if (offset >= this.size - (this.bMin + options.snapOffset + this.bGutterSize)) {
+                offset = this.size - (this.bMin + this.bGutterSize)
             }
 
+            // Actually adjust the size.
             adjust.call(this, offset)
 
+            // Call the drag callback continously. Don't do anything too intensive
+            // in this callback.
             if (options.onDrag) {
                 options.onDrag()
             }
         }
+
+      // Cache some important sizes when drag starts, so we don't have to do that
+      // continously:
+      // 
+      // `size`: The total size of the pair. First element + second element + first gutter + second gutter.
+      // `percentage`: The percentage between 0-100 that the pair occupies in the parent.
+      // `start`: The leading side of the first element.
+      //
+      // ------------------------------------------------ - - - - - - - - - - -
+      // |      aGutterSize -> |||                      |                     |
+      // |                     |||                      |                     |
+      // |                     |||                      |                     |
+      // |                     ||| <- bGutterSize       |                     |
+      // ------------------------------------------------ - - - - - - - - - - -
+      // | <- start                             size -> |       parentSize -> |
       , calculateSizes = function () {
-            // Calculate the pairs size, and percentage of the parent size
+            // Figure out the parent size minus padding.
             var computedStyle = global.getComputedStyle(this.parent)
               , parentSize = this.parent[clientDimension] - parseFloat(computedStyle[paddingA]) - parseFloat(computedStyle[paddingB])
 
@@ -216,13 +343,21 @@ var global = this
             this.percentage = Math.min(this.size / parentSize * 100, 100)
             this.start = this.a[getBoundingClientRect]()[position]
         }
-      , adjust = function (offset) {
-            // A size is the same as offset. B size is total size - A size.
-            // Both sizes are calculated from the initial parent percentage.
 
+      // Actually adjust the size of elements `a` and `b` to `offset` while dragging.
+      // calc is used to allow calc(percentage + gutterpx) on the whole split instance,
+      // which allows the viewport to be resized without additional logic.
+      // Element a's size is the same as offset. b's size is total size - a size.
+      // Both sizes are calculated from the initial parent percentage, then the gutter size is subtracted.
+      , adjust = function (offset) {
             this.a.style[dimension] = calc + '(' + (offset / this.size * this.percentage) + '% - ' + this.aGutterSize + 'px)'
             this.b.style[dimension] = calc + '(' + (this.percentage - (offset / this.size * this.percentage)) + '% - ' + this.bGutterSize + 'px)'
         }
+
+      // 4. Define a few more functions that "balance" the entire split instance.
+      // Split.js tries it's best to cope with min sizes that don't add up.
+      // At some point this should go away since it breaks out of the calc(% - px) model.
+      // Maybe it's a user error if you pass uncomputable minSizes.
       , fitMin = function () {
             var self = this
               , a = self.a
@@ -260,9 +395,31 @@ var global = this
                 fitMinReverse.call(pairs[i])
             }
         }
-      , preventSelection = function () { return false }
+      , setElementSize = function (el, size, gutterSize) {
+            // Split.js allows setting sizes via numbers (ideally), or if you must,
+            // by string, like '300px'. This is less than ideal, because it breaks
+            // the fluid layout that `calc(% - px)` provides. You're on your own if you do that,
+            // make sure you calculate the gutter size by hand.
+            if (typeof size !== 'string' && !(size instanceof String)) {
+                if (!isIE8) {
+                    size = calc + '(' + size + '% - ' + gutterSize + 'px)'
+                } else {
+                    size = options.sizes[i] + '%'
+                }
+            }
+
+            el.style[dimension] = size
+        }
+
+      // No-op function to prevent default. Used to prevent selection.
+      , noop = function () { return false }
+
+      // All DOM elements in the split should have a common parent. We can grab
+      // the first elements parent and hope users read the docs because the
+      // behavior will be whacky otherwise.
       , parent = elementOrSelector(ids[0]).parentNode
 
+    // Set default options.sizes to equal percentages of the parent element.
     if (!options.sizes) {
         var percent = 100 / ids.length
 
@@ -273,6 +430,8 @@ var global = this
         }
     }
 
+    // Standardize minSize to an array if it isn't already. This allows minSize
+    // to be passed as a number.
     if (!Array.isArray(options.minSize)) {
         var minSizes = []
 
@@ -283,15 +442,34 @@ var global = this
         options.minSize = minSizes
     }
 
+    // 5. Loop through the elements while pairing them off. Every pair gets a
+    // `pair` object, a gutter, and isFirst/isLast properties.
+    //
+    // Basic logic:
+    //
+    // - Starting with the second element `i > 0`, create `pair` objects with
+    //   `a = ids[i - 1]` and `b = ids[i]`
+    // - Set gutter sizes based on the _pair_ being first/last. The first and last
+    //   pair have gutterSize / 2, since they only have one half gutter, and not two.
+    // - Create gutter elements and add event listeners.
+    // - Set the size of the elements, minus the gutter sizes.
+    //
+    // -----------------------------------------------------------------------
+    // |     i=0     |         i=1         |        i=2       |      i=3     |
+    // |             |       isFirst       |                  |     isLast   |
+    // |           pair 0                pair 1             pair 2           |
+    // |             |                     |                  |              |
+    // -----------------------------------------------------------------------
     for (i = 0; i < ids.length; i++) {
         var el = elementOrSelector(ids[i])
-          , isFirst = (i == 1)
+          , isFirstPair = (i == 1)
-          , isLast = (i == ids.length - 1)
+          , isLastPair = (i == ids.length - 1)
-          , size
+          , size = options.sizes[i]
           , gutterSize = options.gutterSize
           , pair
 
         if (i > 0) {
+            // Create the pair object with it's metadata.
             pair = {
                 a: elementOrSelector(ids[i - 1]),
                 b: el,
@@ -299,27 +477,31 @@ var global = this
                 bMin: options.minSize[i],
                 dragging: false,
                 parent: parent,
-                isFirst: isFirst,
+                isFirst: isFirstPair,
-                isLast: isLast,
+                isLast: isLastPair,
                 direction: options.direction
             }
 
             // For first and last pairs, first and last gutter width is half.
-
             pair.aGutterSize = options.gutterSize
             pair.bGutterSize = options.gutterSize
 
-            if (isFirst) {
+            if (isFirstPair) {
                 pair.aGutterSize = options.gutterSize / 2
             }
 
-            if (isLast) {
+            if (isLastPair) {
                 pair.bGutterSize = options.gutterSize / 2
             }
         }
 
+        // Determine the size of the current element. IE8 is supported by
+        // staticly assigning sizes without draggable gutters. Assigns a string
+        // to `size`.
+        // 
         // IE9 and above
         if (!isIE8) {
+            // Create gutter elements for each pair.
             if (i > 0) {
                 var gutter = document.createElement('div')
 
@@ -334,35 +516,62 @@ var global = this
                 pair.gutter = gutter
             }
 
+            // Half-size gutters for first and last elements.
             if (i === 0 || i == ids.length - 1) {
                 gutterSize = options.gutterSize / 2
             }
-
-            if (typeof options.sizes[i] === 'string' || options.sizes[i] instanceof String) {
-                size = options.sizes[i]
-            } else {
-                size = calc + '(' + options.sizes[i] + '% - ' + gutterSize + 'px)'
-            }
-
-        // IE8 and below
-        } else {
-            if (typeof options.sizes[i] === 'string' || options.sizes[i] instanceof String) {
-                size = options.sizes[i]
-            } else {
-                size = options.sizes[i] + '%'
-            }
         }
 
-        el.style[dimension] = size
+        // Set the element size to our determined size.
+        setElementSize(el, size, gutterSize)
 
+        // After the first iteration, and we have a pair object, append it to the
+        // list of pairs.
         if (i > 0) {
             pairs.push(pair)
         }
     }
 
+    // Balance the pairs to try to accomodate min sizes.
     balancePairs(pairs)
+
+    return {
+        setSizes: function (sizes) {
+            for (var i = 0; i < sizes.length; i++) {
+                if (i > 0) {
+                    var pair = pairs[i - 1]
+
+                    setElementSize(pair.a, sizes[i - 1], pair.aGutterSize)
+                    setElementSize(pair.b, sizes[i], pair.bGutterSize)
+                }
+            }
+        },
+        collapse: function (i) {
+            var pair
+
+            if (i === pairs.length) {
+                pair = pairs[i - 1]
+
+                calculateSizes.call(pair)
+                adjust.call(pair, pair.size - pair.bGutterSize)
+            } else {
+                pair = pairs[i]
+
+                calculateSizes.call(pair)
+                adjust.call(pair, pair.aGutterSize)
+            }
+        },
+        destroy: function () {
+            for (var i = 0; i < pairs.length; i++) {
+                pairs[i].parent.removeChild(pairs[i].gutter)
+                pairs[i].a.style[dimension] = ''
+                pairs[i].b.style[dimension] = ''
+            }
+        }
+    }
 }
 
+// Play nicely with module systems, and the browser too if you include it raw.
 if (typeof exports !== 'undefined') {
     if (typeof module !== 'undefined' && module.exports) {
         exports = module.exports = Split
@@ -372,4 +581,5 @@ if (typeof exports !== 'undefined') {
     global.Split = Split
 }
 
+// Call our wrapper function with the current global. In this case, `window`.
 }).call(window);

src/js/views/html/HTMLApp.js

@@ -205,14 +205,14 @@ HTMLApp.prototype.populate_operations_list = function() {
  * Sets up the adjustable splitter to allow the user to resize areas of the page.
  */
 HTMLApp.prototype.initialise_splitter = function() {
-    Split(["#operations", "#recipe", "#IO"], {
+    this.column_splitter = Split(["#operations", "#recipe", "#IO"], {
         sizes: [20, 30, 50],
         minSize: [240, 325, 500],
         gutterSize: 4,
         onDrag: this.manager.controls.adjust_width.bind(this.manager.controls)
     });
 
-    Split(["#input", "#output"], {
+    this.io_splitter = Split(["#input", "#output"], {
         direction: "vertical",
         gutterSize: 4,
     });
@@ -463,11 +463,8 @@ HTMLApp.prototype.set_recipe_config = function(recipe_config) {
  * Resets the splitter positions to default.
  */
 HTMLApp.prototype.reset_layout = function() {
-    document.getElementById("operations").style.width = "calc(20% - 2px)";
+    this.column_splitter.setSizes([20, 30, 50]);
-    document.getElementById("recipe").style.width = "calc(30% - 4px)";
+    this.io_splitter.setSizes([50, 50]);
-    document.getElementById("IO").style.width = "calc(50% - 2px)";
-    document.getElementById("input").style.height = "calc(50% - 2px)";
-    document.getElementById("output").style.height = "calc(50% - 2px)";
 
     this.manager.controls.adjust_width();
 };

src/js/views/html/Manager.js

@@ -125,6 +125,7 @@ Manager.prototype.initialise_event_listeners = function() {
     document.getElementById("save-to-file").addEventListener("click", this.output.save_click.bind(this.output));
     document.getElementById("switch").addEventListener("click", this.output.switch_click.bind(this.output));
     document.getElementById("undo-switch").addEventListener("click", this.output.undo_switch_click.bind(this.output));
+    document.getElementById("maximise-output").addEventListener("click", this.output.maximise_output_click.bind(this.output));
     document.getElementById("output-text").addEventListener("scroll", this.highlighter.output_scroll.bind(this.highlighter));
     document.getElementById("output-text").addEventListener("mouseup", this.highlighter.output_mouseup.bind(this.highlighter));
     document.getElementById("output-text").addEventListener("mousemove", this.highlighter.output_mousemove.bind(this.highlighter));

src/js/views/html/OutputWaiter.js

@@ -137,3 +137,23 @@ OutputWaiter.prototype.undo_switch_click = function() {
     this.app.set_input(this.switch_orig_data);
     document.getElementById("undo-switch").disabled = true;
 };
+
+
+/**
+ * Handler for maximise output click events.
+ * Resizes the output frame to be as large as possible, or restores it to its original size.
+ */
+OutputWaiter.prototype.maximise_output_click = function(e) {
+    var el = e.target;
+    
+    if (el.textContent.indexOf("Max") >= 0) {
+        this.app.column_splitter.collapse(0);
+        this.app.column_splitter.collapse(1);
+        this.app.io_splitter.collapse(0);
+
+        el.innerHTML = "<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAlUlEQVQ4y93RwQpBQRQG4C9ba1fxBteGPIj38BTejFJKLFnwCJIiCsW1mcV0k9yx82/OzGK+OXMGOpiiLTFjFNiilQI0sQ7IJiAjLKsgGVYB2YdaVO0kwy46/BVQi9ZDNPyQWen2ub/KufS8y7shfkq9tF9U7SC+/YluKvAI9YZeFeCECXJcA3JHP2WgMXJM/ZUcBwxeM+YuSWTgMtUAAAAASUVORK5CYII='> Restore";
+    } else {
+        this.app.reset_layout();
+        el.innerHTML = "<img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAi0lEQVQ4y83TMQrCQBCF4S+5g4rJEdJ7KE+RQ1lrIQQCllroEULuoM0Ww3a7aXwwLAzMPzDvLcz4hnooUItT1rsoVNy+4lgLWNL7RlcCmDBij2eCfNCrUITc0dRCrhj8m5otw0O6SV8LuAV3uhrAAa8sJ2Np7KPFawhgscVLjH9bCDhjt8WNKft88w/HjCvuVqu53QAAAABJRU5ErkJggg=='> Max";
+    }
+};

src/static/stats.txt

@@ -1,21 +1,21 @@
-204	source files
+206	source files
-113086	lines
+113322	lines
 4.2M	size
 
 137	JavaScript source files
-103936	lines
+104164	lines
 3.7M	size
 
 79	third party JavaScript source files
-84842	lines
+85052	lines
 3.0M	size
 
 58	first party JavaScript source files
-19094	lines
+19112	lines
 724K	size
 
 3.4M	uncompressed JavaScript size
-1.7M	compressed JavaScript size
+1.8M	compressed JavaScript size
 
 15	categories
 157	operations