Layout grids

src/lib/coerce.js

@@ -257,19 +257,56 @@ exports.valObjectMeta = {
             'An {array} of plot information.'
         ].join(' '),
         requiredOpts: ['items'],
-        otherOpts: ['dflt', 'freeLength'],
+        // set dimensions=2 for a 2D array
+        // `items` may be a single object instead of an array, in which case
+        // `freeLength` must be true.
+        otherOpts: ['dflt', 'freeLength', 'dimensions'],
         coerceFunction: function(v, propOut, dflt, opts) {
+
+            // simplified coerce function just for array items
+            function coercePart(v, opts, dflt) {
+                var out;
+                var propPart = {set: function(v) { out = v; }};
+
+                if(dflt === undefined) dflt = opts.dflt;
+
+                exports.valObjectMeta[opts.valType].coerceFunction(v, propPart, dflt, opts);
+
+                return out;
+            }
+
+            var twoD = opts.dimensions === 2;
+
             if(!Array.isArray(v)) {
                 propOut.set(dflt);
                 return;
             }
 
-            var items = opts.items,
-                vOut = [];
+            var items = opts.items;
+            var vOut = [];
+            var arrayItems = Array.isArray(items);
+            var len = arrayItems ? items.length : v.length;
+
+            var i, j, len2, vNew;
+
             dflt = Array.isArray(dflt) ? dflt : [];
 
-            for(var i = 0; i < items.length; i++) {
-                exports.coerce(v, vOut, items, '[' + i + ']', dflt[i]);
+            if(twoD) {
+                for(i = 0; i < len; i++) {
+                    vOut[i] = [];
+                    var row = Array.isArray(v[i]) ? v[i] : [];
+                    len2 = arrayItems ? items[i].length : row.length;
+                    for(j = 0; j < len2; j++) {
+                        vNew = coercePart(row[j], arrayItems ? items[i][j] : items, (dflt[i] || [])[j]);
+                        if(vNew !== undefined) vOut[i][j] = vNew;
+                    }
+                }
+            }
+            else {
+                for(i = 0; i < len; i++) {
+                    vNew = coercePart(v[i], arrayItems ? items[i] : items, dflt[i]);
+                    if(vNew !== undefined) vOut[i] = vNew;
+                }
             }
 
             propOut.set(vOut);
@@ -278,15 +315,25 @@ exports.valObjectMeta = {
             if(!Array.isArray(v)) return false;
 
             var items = opts.items;
+            var arrayItems = Array.isArray(items);
+            var twoD = opts.dimensions === 2;
 
             // when free length is off, input and declared lengths must match
             if(!opts.freeLength && v.length !== items.length) return false;
 
             // valid when all input items are valid
             for(var i = 0; i < v.length; i++) {
-                var isItemValid = exports.validate(v[i], opts.items[i]);
-
-                if(!isItemValid) return false;
+                if(twoD) {
+                    if(!Array.isArray(v[i]) || (!opts.freeLength && v[i].length !== items[i].length)) {
+                        return false;
+                    }
+                    for(var j = 0; j < v[i].length; j++) {
+                        if(!exports.validate(v[i][j], arrayItems ? items[i][j] : items)) {
+                            return false;
+                        }
+                    }
+                }
+                else if(!exports.validate(v[i], arrayItems ? items[i] : items)) return false;
             }
 
             return true;

src/lib/regex.js

@@ -8,16 +8,19 @@
 
 'use strict';
 
-// Simple helper functions
-// none of these need any external deps
-
 /*
  * make a regex for matching counter ids/names ie xaxis, xaxis2, xaxis10...
- *  eg: regexCounter('x')
- * tail is an optional piece after the id
- *  eg regexCounter('scene', '.annotations') for scene2.annotations etc.
+ *
+ * @param {string} head: the head of the pattern, eg 'x' matches 'x', 'x2', 'x10' etc.
+ *      'xy' is a special case for cartesian subplots: it matches 'x2y3' etc
+ * @param {Optional(string)} tail: a fixed piece after the id
+ *      eg counterRegex('scene', '.annotations') for scene2.annotations etc.
+ * @param {boolean} openEnded: if true, the string may continue past the match.
  */
 exports.counter = function(head, tail, openEnded) {
-    return new RegExp('^' + head + '([2-9]|[1-9][0-9]+)?' +
-        (tail || '') + (openEnded ? '' : '$'));
+    var fullTail = (tail || '') + (openEnded ? '' : '$');
+    if(head === 'xy') {
+        return new RegExp('^x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?' + fullTail);
+    }
+    return new RegExp('^' + head + '([2-9]|[1-9][0-9]+)?' + fullTail);
 };

src/lib/stats.js

@@ -28,7 +28,7 @@ var isNumeric = require('fast-isnumeric');
 exports.aggNums = function(f, v, a, len) {
     var i,
         b;
-    if(!len) len = a.length;
+    if(!len || len > a.length) len = a.length;
     if(!isNumeric(v)) v = false;
     if(Array.isArray(a[0])) {
         b = new Array(len);

src/plot_api/plot_schema.js

@@ -383,7 +383,8 @@ function recurseIntoValObject(valObject, parts, i) {
     }
 
     // now recurse as far as we can. Occasionally we have an attribute
-    // setting an internal part below what's
+    // setting an internal part below what's in the schema; just return
+    // the innermost schema item we find.
     for(; i < parts.length; i++) {
         var newValObject = valObject[parts[i]];
         if(Lib.isPlainObject(newValObject)) valObject = newValObject;
@@ -398,8 +399,23 @@ function recurseIntoValObject(valObject, parts, i) {
         else if(valObject.valType === 'info_array') {
             i++;
             var index = parts[i];
-            if(!isIndex(index) || index >= valObject.items.length) return false;
-            valObject = valObject.items[index];
+            if(!isIndex(index)) return false;
+
+            var items = valObject.items;
+            if(Array.isArray(items)) {
+                if(index >= items.length) return false;
+                if(valObject.dimensions === 2) {
+                    i++;
+                    if(parts.length === i) return valObject;
+                    var index2 = parts[i];
+                    if(!isIndex(index2)) return false;
+                    valObject = items[index][index2];
+                }
+                else valObject = items[index];
+            }
+            else {
+                valObject = items;
+            }
         }
     }
 

src/plots/cartesian/constants.js

@@ -7,7 +7,7 @@
 */
 
 'use strict';
-var counterRegex = require('../../lib').counterRegex;
+var counterRegex = require('../../lib/regex').counter;
 
 
 module.exports = {

src/plots/cartesian/layout_defaults.js

@@ -161,7 +161,8 @@ module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
         var positioningOptions = {
             letter: axLetter,
             counterAxes: counterAxes[axLetter],
-            overlayableAxes: overlayableAxes
+            overlayableAxes: overlayableAxes,
+            grid: layoutOut.grid
         };
 
         handlePositionDefaults(axLayoutIn, axLayoutOut, coerce, positioningOptions);

src/plots/cartesian/position_defaults.js

@@ -15,26 +15,43 @@ var Lib = require('../../lib');
 
 
 module.exports = function handlePositionDefaults(containerIn, containerOut, coerce, options) {
-    var counterAxes = options.counterAxes || [],
-        overlayableAxes = options.overlayableAxes || [],
-        letter = options.letter;
+    var counterAxes = options.counterAxes || [];
+    var overlayableAxes = options.overlayableAxes || [];
+    var letter = options.letter;
+    var grid = options.grid;
+
+    var dfltAnchor, dfltDomain, dfltSide, dfltPosition;
+
+    if(grid) {
+        dfltDomain = grid._domains[letter][grid._axisMap[containerOut._id]];
+        dfltAnchor = grid._anchors[containerOut._id];
+        if(dfltDomain) {
+            dfltSide = grid[letter + 'side'].split(' ')[0];
+            dfltPosition = grid.domain[letter][dfltSide === 'right' || dfltSide === 'top' ? 1 : 0];
+        }
+    }
+
+    // Even if there's a grid, this axis may not be in it - fall back on non-grid defaults
+    dfltDomain = dfltDomain || [0, 1];
+    dfltAnchor = dfltAnchor || (isNumeric(containerIn.position) ? 'free' : (counterAxes[0] || 'free'));
+    dfltSide = dfltSide || (letter === 'x' ? 'bottom' : 'left');
+    dfltPosition = dfltPosition || 0;
 
     var anchor = Lib.coerce(containerIn, containerOut, {
         anchor: {
             valType: 'enumerated',
             values: ['free'].concat(counterAxes),
-            dflt: isNumeric(containerIn.position) ? 'free' :
-                (counterAxes[0] || 'free')
+            dflt: dfltAnchor
         }
     }, 'anchor');
 
-    if(anchor === 'free') coerce('position');
+    if(anchor === 'free') coerce('position', dfltPosition);
 
     Lib.coerce(containerIn, containerOut, {
         side: {
             valType: 'enumerated',
             values: letter === 'x' ? ['bottom', 'top'] : ['left', 'right'],
-            dflt: letter === 'x' ? 'bottom' : 'left'
+            dflt: dfltSide
         }
     }, 'side');
 
@@ -54,9 +71,9 @@ module.exports = function handlePositionDefaults(containerIn, containerOut, coer
         // in ax.setscale()... but this means we still need (imperfect) logic
         // in the axes popover to hide domain for the overlaying axis.
         // perhaps I should make a private version _domain that all axes get???
-        var domain = coerce('domain');
-        if(domain[0] > domain[1] - 0.01) containerOut.domain = [0, 1];
-        Lib.noneOrAll(containerIn.domain, containerOut.domain, [0, 1]);
+        var domain = coerce('domain', dfltDomain);
+        if(domain[0] > domain[1] - 0.01) containerOut.domain = dfltDomain;
+        Lib.noneOrAll(containerIn.domain, containerOut.domain, dfltDomain);
     }
 
     coerce('layer');

src/plots/domain_attributes.js → src/plots/domain.js

@@ -20,6 +20,8 @@ var extendFlat = require('../lib/extend').extendFlat;
  *     opts.trace: set to true for trace containers
  *   @param {string}
  *     opts.editType: editType for all pieces
+ *   @param {boolean}
+ *     opts.noGridCell: set to true to omit `row` and `column`
  *
  * @param {object} extra
  *   @param {string}
@@ -29,7 +31,7 @@ var extendFlat = require('../lib/extend').extendFlat;
  *
  * @return {object} attributes object containing {x,y} as specified
  */
-module.exports = function(opts, extra) {
+exports.attributes = function(opts, extra) {
     opts = opts || {};
     extra = extra || {};
 
@@ -48,7 +50,7 @@ module.exports = function(opts, extra) {
     var contPart = opts.trace ? 'trace ' : 'subplot ';
     var descPart = extra.description ? ' ' + extra.description : '';
 
-    return {
+    var out = {
         x: extendFlat({}, base, {
             description: [
                 'Sets the horizontal domain of this ',
@@ -69,4 +71,60 @@ module.exports = function(opts, extra) {
         }),
         editType: opts.editType
     };
+
+    if(!opts.noGridCell) {
+        out.row = {
+            valType: 'integer',
+            min: 0,
+            role: 'info',
+            editType: opts.editType,
+            description: [
+                'If there is a layout grid, use the domain ',
+                'for this row in the grid for this ',
+                namePart,
+                contPart,
+                '.',
+                descPart
+            ].join('')
+        };
+        out.column = {
+            valType: 'integer',
+            min: 0,
+            role: 'info',
+            editType: opts.editType,
+            description: [
+                'If there is a layout grid, use the domain ',
+                'for this column in the grid for this ',
+                namePart,
+                contPart,
+                '.',
+                descPart
+            ].join('')
+        };
+    }
+
+    return out;
+};
+
+exports.defaults = function(containerOut, layout, coerce, dfltDomains) {
+    var dfltX = (dfltDomains && dfltDomains.x) || [0, 1];
+    var dfltY = (dfltDomains && dfltDomains.y) || [0, 1];
+
+    var grid = layout.grid;
+    if(grid) {
+        var column = coerce('domain.column');
+        if(column !== undefined) {
+            if(column < grid.columns) dfltX = grid._domains.x[column];
+            else delete containerOut.domain.column;
+        }
+
+        var row = coerce('domain.row');
+        if(row !== undefined) {
+            if(row < grid.rows) dfltY = grid._domains.y[row];
+            else delete containerOut.domain.row;
+        }
+    }
+
+    coerce('domain.x', dfltX);
+    coerce('domain.y', dfltY);
 };

src/plots/geo/layout/layout_attributes.js

@@ -9,7 +9,7 @@
 'use strict';
 
 var colorAttrs = require('../../../components/color/attributes');
-var domainAttrs = require('../../domain_attributes');
+var domainAttrs = require('../../domain').attributes;
 var constants = require('../constants');
 var overrideAll = require('../../../plot_api/edit_types').overrideAll;
 

src/plots/gl3d/layout/layout_attributes.js

@@ -10,7 +10,7 @@
 'use strict';
 
 var gl3dAxisAttrs = require('./axis_attributes');
-var domainAttrs = require('../../domain_attributes');
+var domainAttrs = require('../../domain').attributes;
 var extendFlat = require('../../../lib/extend').extendFlat;
 var counterRegex = require('../../../lib').counterRegex;