From 9482deeb832c6c43e7732a3ef6537411ae6f5cce Mon Sep 17 00:00:00 2001
From: Jonathan Eiten <jonathan.eiten@mojotouch.com>
Date: Thu, 15 Mar 2018 13:51:26 -0400
Subject: [PATCH 1/3] fixed single-column-after-fixed-columns render issue

---
 README.md                | 4 ++--
 demo/index.html          | 2 +-
 demo/multiple-grids.html | 2 +-
 demo/row-props.html      | 2 +-
 package-lock.json        | 2 +-
 package.json             | 2 +-
 src/renderer/index.js    | 3 +++
 7 files changed, 10 insertions(+), 7 deletions(-)
diff --git a/README.md b/README.md
index c3fd472b6..2de06b955 100644
--- a/README.md
+++ b/README.md
@@ -16,9 +16,9 @@ It also highlights a DOM-based custom external editor triggered via hypergrid ev
 * [Roadmap](#roadmap)
 * [Contributing](#contributors)
 
-### Current Release (2.1.5 - 6 March 2018)
+### Current Release (2.1.6 - 16 March 2018)
 
-**Hypergrid 2.1.5** includes bug fixes.
+**Hypergrid 2.1.6** includes bug fixes.
 
 _For a complete list of changes, see the [release notes](https://github.com/fin-hypergrid/core/releases)._
 
diff --git a/demo/index.html b/demo/index.html
index 6873d555b..801492fe6 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -12,7 +12,7 @@
 
 </head>
 <body>
-    <h1 style="margin:.5em; color:lightgrey">Hypergrid 2.1.5 dev testbench</h1>
+    <h1 style="margin:.5em; color:lightgrey">Hypergrid 2.1.6 dev testbench</h1>
 
     <div id="tabs">
         <div id="tab-dashboard">Dashboard</div>
diff --git a/demo/multiple-grids.html b/demo/multiple-grids.html
index 88767161e..d664966a6 100644
--- a/demo/multiple-grids.html
+++ b/demo/multiple-grids.html
@@ -5,7 +5,7 @@
     <style> body > div.hypergrid-container { width: 415px; margin-right: 10px; display: inline-block }</style>
 </head>
 <body>
-<h1 style="margin:.5em; color:lightgrey">Hypergrid 2.1.5 multiple grids demo</h1>
+<h1 style="margin:.5em; color:lightgrey">Hypergrid 2.1.6 multiple grids demo</h1>
 
 <script src="build/fin-hypergrid.js"></script>
 
diff --git a/demo/row-props.html b/demo/row-props.html
index 940fdaec8..4fb2b48c9 100644
--- a/demo/row-props.html
+++ b/demo/row-props.html
@@ -38,7 +38,7 @@
     </style>
 </head>
 <body>
-<h1 style="margin:.5em; color:lightgrey">Hypergrid 2.1.5 performance workbench</h1>
+<h1 style="margin:.5em; color:lightgrey">Hypergrid 2.1.6 performance workbench</h1>
 
 <div id="controls" class="nowrap">
     <label id="controller" title="Uncheck to hide other controls.">
diff --git a/package-lock.json b/package-lock.json
index 157c76fb9..8538bfb80 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "fin-hypergrid",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
diff --git a/package.json b/package.json
index f7d943b82..1d47cdaec 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fin-hypergrid",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "Canvas-based high-performance grid",
   "repository": {
     "type": "git",
diff --git a/src/renderer/index.js b/src/renderer/index.js
index 37956b216..388ce19ee 100644
--- a/src/renderer/index.js
+++ b/src/renderer/index.js
@@ -1242,6 +1242,7 @@ function computeCellsBounds() {
 
         width = Math.ceil(behavior.getColumnWidth(vx));
 
+        gap = false;
         if (x) {
             if ((gap = hasFixedColumnGap && c === fixedColumnCount)) {
                 x += fixedWidthV - lineWidthV;
@@ -1256,6 +1257,7 @@ function computeCellsBounds() {
             left = x;
             widthSpaced = width;
         }
+
         this.visibleColumns[c] = this.visibleColumnsByIndex[vx] = vc = {
             index: c,
             columnIndex: vx,
@@ -1298,6 +1300,7 @@ function computeCellsBounds() {
         // For each row of each subgrid...
         for (R = r + subrows; r < R && y < Y; r++) {
             vy = r;
+            gap = false;
             if (scrollableSubgrid) {
                 if ((gap = hasFixedRowGap && r === fixedRowCount)) {
                     y += fixedWidthH - lineWidthH;

From 30fcd0da1233a4c8c8401fcda69c8a35384fc789 Mon Sep 17 00:00:00 2001
From: Jonathan Eiten <jonathan.eiten@mojotouch.com>
Date: Fri, 16 Mar 2018 11:26:01 -0400
Subject: [PATCH 2/3] added restoreRowSelections & restoreColumnSelections
 properties and check those instead of checkboxOnlyRowSelections; removed
 region selections after reindex

---
 demo/js/demo/index.js     |  6 ++--
 src/behaviors/Behavior.js | 14 ++++----
 src/dataModels/JSON.js    | 71 +++++++++++++++++++++++++++------------
 src/defaults.js           | 16 +++++++++
 4 files changed, 73 insertions(+), 34 deletions(-)

diff --git a/demo/js/demo/index.js b/demo/js/demo/index.js
index 1b4376f93..c1a91c385 100644
--- a/demo/js/demo/index.js
+++ b/demo/js/demo/index.js
@@ -45,11 +45,9 @@ window.onload = function() {
     console.log('Indexes:'); console.dir(idx);
 
     function setData(data, options) {
-        options = !data.length ? undefined : options || {
-            schema: Hypergrid.lib.fields.getSchema(data)
-        };
+        options = Object.assign({}, options);
+        options.schema = options.schema || [];
         grid.setData(data, options);
-        behavior.reindex();
     }
 
     function reset() {
diff --git a/src/behaviors/Behavior.js b/src/behaviors/Behavior.js
index 12543f2da..66d129eb0 100644
--- a/src/behaviors/Behavior.js
+++ b/src/behaviors/Behavior.js
@@ -201,18 +201,16 @@ var Behavior = Base.extend('Behavior', {
     },
 
     /**
-     * The "grid index" given a "data index" (or column object)
+     * The "grid index" of an active column given a "data index" (number), column name (string), or column object
      * @param {Column|number} columnOrIndex
      * @returns {undefined|number} The grid index of the column or undefined if column not in grid.
      * @memberOf Hypergrid#
      */
-    getActiveColumnIndex: function(columnOrIndex) {
-        var index = columnOrIndex instanceof Column ? columnOrIndex.index : columnOrIndex;
-        for (var i = 0; i < this.columns.length; ++i) {
-            if (this.columns[i].index === index) {
-                return i;
-            }
-        }
+    getActiveColumnIndex: function(columnOrIndexOrName) {
+        var value = columnOrIndexOrName instanceof Column ? columnOrIndexOrName.index : columnOrIndexOrName,
+            key = typeof index === 'number' ? 'index' : 'name';
+
+        return this.columns.findIndex(function(column) { return column[key] === value; });
     },
 
     getVisibleColumn: function() {
diff --git a/src/dataModels/JSON.js b/src/dataModels/JSON.js
index 8f604e2f3..51eeae158 100644
--- a/src/dataModels/JSON.js
+++ b/src/dataModels/JSON.js
@@ -219,7 +219,8 @@ var JSON = DataModel.extend('dataModels.JSON', {
      * @memberOf dataModels.JSON.prototype
      */
     reindex: function(options) {
-        var selectedRowSourceIndexes = getUnderlyingIndexesOfSelectedRows.call(this);
+        var selectedRowSourceIndexes = getSelectedDataRowIndexes.call(this),
+            selectedColumnNames = getSelectedColumNames.call(this);
 
         this.pipeline.forEach(function(dataSource) {
             if (dataSource) {
@@ -229,7 +230,10 @@ var JSON = DataModel.extend('dataModels.JSON', {
             }
         });
 
+        this.grid.selectionModel.reset();
+
         reselectRowsByUnderlyingIndexes.call(this, selectedRowSourceIndexes);
+        reselectColumnsByNames.call(this, selectedColumnNames);
     },
 
     /**
@@ -721,50 +725,73 @@ var JSON = DataModel.extend('dataModels.JSON', {
  * @this {dataModels.JSON}
  * @memberOf dataModels.JSON~
  */
-function getUnderlyingIndexesOfSelectedRows() {
-    var sourceIndexes = [],
-        dataSource = this.dataSource;
+function getSelectedDataRowIndexes() {
+    if (this.grid.properties.restoreRowSelections) {
+        var dataSource = this.dataSource;
 
-    if (this.grid.properties.checkboxOnlyRowSelections) {
-        this.grid.getSelectedRows().forEach(function(selectedRowIndex) {
-            sourceIndexes.push(dataSource.getDataIndex(selectedRowIndex));
+        return this.grid.getSelectedRows().map(function(selectedRowIndex) {
+            return dataSource.getDataIndex(selectedRowIndex);
         });
     }
+}
+
+function getSelectedColumNames() {
+    if (this.grid.properties.restoreColumnSelections) {
+        var behavior = this.grid.behavior;
 
-    return sourceIndexes;
+        return this.grid.getSelectedColumns().map(function(selectedColumnIndex) {
+            return behavior.getActiveColumn(selectedColumnIndex).name;
+        });
+    }
 }
 
 /**
  * Re-establish grid row selections based on underlying data row indexes saved by `getSelectedDataRowsBackingSelectedGridRows` which should be called first.
  * @private
  * @this {dataModels.JSON}
+ * @param {number[]} [dataRowIndexes] - List of underlying data row indexes. If omitted, this function is a no-op.
+ * @returns {number} Number of rows reselected or `undefined` if `dataRowIndexes` was undefined.
  * @memberOf dataModels.JSON~
  */
-function reselectRowsByUnderlyingIndexes(sourceIndexes) {
-    var i, r,
-        rowCount = this.getRowCount(),
-        selectedRowCount = sourceIndexes.length,
-        rowIndexes = [],
-        selectionModel = this.grid.selectionModel;
-
-    selectionModel.clearRowSelection();
+function reselectRowsByUnderlyingIndexes(dataRowIndexes) {
+    if (dataRowIndexes) {
+        var i, r,
+            rowCount = this.getRowCount(),
+            selectedRowCount = dataRowIndexes.length,
+            gridRowIndexes = [],
+            selectionModel = this.grid.selectionModel;
 
-    if (this.grid.properties.checkboxOnlyRowSelections) {
         for (r = 0; selectedRowCount && r < rowCount; ++r) {
-            i = sourceIndexes.indexOf(this.dataSource.getDataIndex(r));
+            i = dataRowIndexes.indexOf(this.dataSource.getDataIndex(r));
             if (i >= 0) {
-                rowIndexes.push(r);
-                delete sourceIndexes[i]; // might make indexOf increasingly faster as deleted elements are not enumerable
+                gridRowIndexes.push(r);
+                delete dataRowIndexes[i]; // might make indexOf increasingly faster as deleted elements are not enumerable
                 selectedRowCount--; // count down so we can bail early if all found
             }
         }
 
-        rowIndexes.forEach(function(rowIndex) {
+        gridRowIndexes.forEach(function(rowIndex) {
             selectionModel.selectRow(rowIndex);
         });
+
+        return gridRowIndexes.length;
     }
+}
+
+function reselectColumnsByNames(sourceColumnNames) {
+    if (sourceColumnNames) {
+        var behavior = this.grid.behavior,
+            selectionModel = this.grid.selectionModel;
 
-    return rowIndexes.length;
+        return sourceColumnNames.reduce(function(reselectedCount, columnName) {
+            var activeColumnIndex = behavior.getActiveColumnIndex(columnName);
+            if (activeColumnIndex) {
+                selectionModel.selectColumn(activeColumnIndex);
+                reselectedCount++;
+            }
+            return reselectedCount;
+        }, 0);
+    }
 }
 
 /**
diff --git a/src/defaults.js b/src/defaults.js
index 055176842..39e4ed5d4 100644
--- a/src/defaults.js
+++ b/src/defaults.js
@@ -1354,6 +1354,22 @@ var defaults = {
         'onhover'
     ],
 
+    /** @summary Restore row selections across data transformations (`reindex` calls).
+     * @desc The restoration is based on the underlying data row indexes.
+     * @type {boolean}
+     * @default
+     * @memberOf module:defaults
+     */
+    restoreRowSelections: true,
+
+    /** @summary Restore column selections across data transformations (`reindex` calls).
+     * @desc The restoration is based on the column names.
+     * @type {boolean}
+     * @default
+     * @memberOf module:defaults
+     */
+    restoreColumnSelections: true,
+
     /** @summary How to truncate text.
      * @desc A "quaternary" value, one of:
      * * `undefined` - Text is not truncated.

From 07e55fcf7f38772f87183b4d98f58a681184820c Mon Sep 17 00:00:00 2001
From: Jonathan Eiten <jonathan.eiten@mojotouch.com>
Date: Wed, 21 Mar 2018 21:09:27 -0400
Subject: [PATCH 3/3] init column props from schema

---
 .npmignore                        |   5 +-
 demo/js/demo/index.js             |  12 +-
 demo/js/demo/setState.js          |  14 +-
 package-lock.json                 |  14 +-
 package.json                      |   5 +-
 src/Hypergrid.js                  |  55 +++++--
 src/behaviors/Behavior.js         | 239 +++++++++++-------------------
 src/behaviors/Column.js           | 231 ++++++++++++++++-------------
 src/behaviors/JSON.js             |  11 +-
 src/behaviors/cellProperties.js   |  18 ++-
 src/behaviors/columnProperties.js |   2 +-
 src/behaviors/rowProperties.js    | 188 +++++++++++++++++++++++
 src/cellEditors/index.js          |  47 +++---
 src/cellRenderers/index.js        |  51 +++----
 src/dataModels/DataModel.js       |  13 +-
 src/defaults.js                   |   7 +-
 src/features/index.js             |  40 +++--
 src/lib/Registry.js               | 114 +++++++-------
 src/lib/cellEventFactory.js       |   6 +-
 src/lib/deprecated.js             |   4 +-
 src/lib/dynamicProperties.js      | 134 ++++++++---------
 src/lib/fields.js                 |  38 +----
 src/lib/misc.js                   |  29 ++++
 23 files changed, 727 insertions(+), 550 deletions(-)
 create mode 100644 src/behaviors/rowProperties.js
 create mode 100644 src/lib/misc.js

diff --git a/.npmignore b/.npmignore
index fb98e1e52..1e798839e 100644
--- a/.npmignore
+++ b/.npmignore
@@ -7,7 +7,6 @@
 /doc
 /html/*.html
 /images/**
-!/images/index.js
 !/images/images.js
 /jsdoc-template-hypergrid
 /src/jsdoc
@@ -18,10 +17,12 @@
 /*.sh
 /*.md
 
-*.index.js
+index.js
 !/index.js
 !/css/index.js
+!/images/index.js
 !/src/cellRenderers/index.js
 !/src/cellEditors/index.js
+!/src/dataModels/index.js
 !/src/renderer/index.js
 !/src/features/index.js
diff --git a/demo/js/demo/index.js b/demo/js/demo/index.js
index c1a91c385..e961e8c1f 100644
--- a/demo/js/demo/index.js
+++ b/demo/js/demo/index.js
@@ -27,10 +27,20 @@ window.onload = function() {
     // convert field names containing underscore to camel case by overriding column enum decorator
     Hypergrid.behaviors.JSON.prototype.columnEnumKey = Hypergrid.behaviors.JSON.columnEnumDecorators.toCamelCase;
 
+    var schema = Hypergrid.lib.fields.getSchema(people1);
+
+    // as of v2.1.6, column properties can also be initialized from custom schema (as well as from a grid state object).
+    // The following demonstrates this. Note that demo/setState.js also sets props of 'height' column. The setState
+    // call therein was changed to addState to accommodate (else schema props defined here would have been cleared).
+    Object.assign(schema.find(function(columnSchema) { return columnSchema.name === 'height'; }), {
+        halign: 'right',
+        // format: 'foot' --- for demo purposes, this prop being set in setState.js (see)
+    });
+
     var gridOptions = {
             data: people1,
             margin: { bottom: '17px', right: '17px'},
-            schema: Hypergrid.lib.fields.getSchema(people1),
+            schema: schema,
             plugins: require('fin-hypergrid-event-logger'),
             state: { color: 'orange' }
         },
diff --git a/demo/js/demo/setState.js b/demo/js/demo/setState.js
index 00600b090..dec8aee5d 100644
--- a/demo/js/demo/setState.js
+++ b/demo/js/demo/setState.js
@@ -61,9 +61,19 @@ module.exports = function(demo, grid) {
             Add10: 'function(dataRow,columnName) { return dataRow[columnName] + 10; }'
         },
 
+        // ANTI-PATTERNS FOLLOW
+        //
+        // Setting column, row, cell props here in a state object is a legacy feature.
+        // Developers may find it more useful to set column props in column schema (as of v2.1.6),
+        // row props in row metadata (as of v2.1.0), and cell props in column metadata (as of v2.0.2),
+        // which would then persist across setState calls which clear these properties objects
+        // before applying new values. In this demo, we have changed the setState call below to addState
+        // (which does not clear the properties object first) to show how to set a column prop here *and*
+        // a different prop on the same column in schema (in index.js).
+
         columns: {
             height: {
-                halign: 'right',
+                // halign: 'right', --- for demo purposes, this prop being set in index.js (see)
                 format: 'foot'
             },
 
@@ -144,7 +154,7 @@ module.exports = function(demo, grid) {
         }
     };
 
-    grid.setState(state);
+    grid.addState(state); // changed from setState so 'height' props set with schema in index.js wouldn't be cleared
 
     grid.takeFocus();
 
diff --git a/package-lock.json b/package-lock.json
index 8538bfb80..9f7edb771 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -2024,12 +2024,9 @@
       "dev": true
     },
     "extend-me": {
-      "version": "2.6.0",
-      "resolved": "https://registry.npmjs.org/extend-me/-/extend-me-2.6.0.tgz",
-      "integrity": "sha512-/2ZwOBxvriDEBkuBLUJGOoJVo+DoguQFdaOgZY1KAUTMEbn1YsVKMCaHWHbBRkNy5LDSeoHCJOm46YuvhspELw==",
-      "requires": {
-        "overrider": "0.3.0"
-      }
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/extend-me/-/extend-me-2.7.0.tgz",
+      "integrity": "sha512-SklO9LFB88+40BdgVOEx1Jhe9lA/+nEEB5Wop270Rhs3EGFRiGMJ3uatSuRGgTfQgub3HdALRPiAXvej4036gg=="
     },
     "extend-shallow": {
       "version": "2.0.1",
@@ -2138,7 +2135,7 @@
       "resolved": "https://registry.npmjs.org/fin-hypergrid-data-source-base/-/fin-hypergrid-data-source-base-0.4.11.tgz",
       "integrity": "sha1-coBp+maMibigGMsLpS7qsA8RFRo=",
       "requires": {
-        "extend-me": "2.6.0"
+        "extend-me": "2.7.0"
       }
     },
     "fin-hypergrid-event-logger": {
@@ -7656,6 +7653,9 @@
       "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=",
       "dev": true
     },
+    "synonomous": {
+      "version": "file:../synonomous"
+    },
     "syntax-error": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/syntax-error/-/syntax-error-1.3.0.tgz",
diff --git a/package.json b/package.json
index 1d47cdaec..19b372acb 100644
--- a/package.json
+++ b/package.json
@@ -16,7 +16,7 @@
   ],
   "dependencies": {
     "chai": "^3.5.0",
-    "extend-me": "^2.3",
+    "extend-me": "^2.7.0",
     "fin-hypergrid-data-source-base": "^0.4.10",
     "fin-hypergrid-event-logger": "^1.0.3",
     "finbars": "1.5.2",
@@ -25,7 +25,8 @@
     "object-iterators": "1.3.0",
     "overrider": "^0",
     "rectangular": "1.0.1",
-    "sparse-boolean-array": "1.0.1"
+    "sparse-boolean-array": "1.0.1",
+    "synonomous": "^1.0.1"
   },
   "devDependencies": {
     "browser-sync": "^2.10.0",
diff --git a/src/Hypergrid.js b/src/Hypergrid.js
index 07e50de49..149efd304 100644
--- a/src/Hypergrid.js
+++ b/src/Hypergrid.js
@@ -19,8 +19,8 @@ var SelectionModel = require('./lib/SelectionModel');
 var Localization = require('./lib/Localization');
 var Behavior = require('./behaviors/Behavior');
 var behaviorJSON = require('./behaviors/JSON');
-var CellRenderers = require('./cellRenderers');
-var CellEditors = require('./cellEditors');
+var cellRenderers = require('./cellRenderers');
+var cellEditors = require('./cellEditors');
 
 var EDGE_STYLES = ['top', 'bottom', 'left', 'right'],
     RECT_STYLES = EDGE_STYLES.concat(['width', 'height', 'position']);
@@ -109,17 +109,19 @@ var Hypergrid = Base.extend('Hypergrid', {
 
         /**
          * @name cellRenderers
-         * @type {CellRenderer}
+         * @type {Registry}
          * @memberOf Hypergrid#
          */
-        this.cellRenderers = new CellRenderers();
+        this.cellRenderers = cellRenderers;
 
         /**
+         * Private version of cell editors registry with a bound `create` method for use by `getCellEditorAt`.
          * @name cellEditors
-         * @type {CellEditor}
+         * @type {Registry}
          * @memberOf Hypergrid#
          */
-        this.cellEditors = new CellEditors({ grid: this });
+        this.cellEditors = Object.create(cellEditors);
+        Object.defineProperty(this.cellEditors, 'create', { value: createCellEditor.bind(this) });
 
         this.initCanvas();
 
@@ -302,7 +304,7 @@ var Hypergrid = Base.extend('Hypergrid', {
             var: { value: new Var() }
         });
 
-        // For all all default props of object type, if a dynamic prop, invoke setter; else deep clone it so changes
+        // For all default props of object type, if a dynamic prop, invoke setter; else deep clone it so changes
         // made to inner props won't go to object on theme or defaults layers which are shared by other instances.
         Object.keys(defaults).forEach(function(key) {
             var value = defaults[key];
@@ -609,7 +611,16 @@ var Hypergrid = Base.extend('Hypergrid', {
      * @see [Memento pattern](http://en.wikipedia.org/wiki/Memento_pattern)
      */
     setState: function(state) {
-        this.behavior.setState(state);
+        this.addState(state, true);
+    },
+
+    /**
+     * @memberOf Hypergrid#
+     * @desc Add to the state object.
+     * @param {object} state
+     */
+    addState: function(state, settingState) {
+        this.behavior.addState(state, settingState);
         this.refreshProperties();
         this.behaviorChanged();
     },
@@ -636,7 +647,10 @@ var Hypergrid = Base.extend('Hypergrid', {
 
         var space = options.space === undefined ? '\t' : options.space,
             properties = this.properties,
-            calculators = properties.calculators;
+            calculators = properties.calculators,
+            blacklist = options.blacklist = options.blacklist || [];
+
+        blacklist.push('columnProperties'); // Never output this synonym of 'columns'
 
         if (calculators) {
             if (options.compact) {
@@ -654,8 +668,8 @@ var Hypergrid = Base.extend('Hypergrid', {
         this.headerify = options.headerify;
 
         var json = JSON.stringify(properties, function(key, value) {
-            if (options.blacklist && this === properties && options.blacklist.indexOf(key) >= 0) {
-                value = undefined;
+            if (this === properties && options.blacklist.indexOf(key) >= 0) {
+                value = undefined; // JSON.stringify ignores undefined props
             } else if (key === 'calculator') {
                 if (calculators) {
                     // convert function reference to registry key
@@ -828,6 +842,13 @@ var Hypergrid = Base.extend('Hypergrid', {
         this.renderer.setInfo(messages);
     },
 
+    /**
+     * @memberOf Behavior#
+     */
+    reindex: function() {
+        this.needsReindex = this.needsShapeChanged = true;
+    },
+
     /**
      * @memberOf Hypergrid#
      * @summary _(See {@link Hypergrid.prototype#setData}.)_
@@ -889,6 +910,11 @@ var Hypergrid = Base.extend('Hypergrid', {
      * Called from renderer/index.js
      */
     deferredBehaviorChange: function() {
+        if (this.needsReindex) {
+            this.behavior.reindex();
+            this.needsReindex = false;
+        }
+
         if (this.needsShapeChanged) {
             if (this.divCanvas) {
                 this.synchronizeScrollingBoundaries(); // calls computeCellsBounds and repaint (state change)
@@ -1946,6 +1972,13 @@ function deepClone(object) {
     return result;
 }
 
+function createCellEditor(name, props) {
+    var CellEditor = cellEditors.get(name);
+    if (CellEditor) {
+        return new CellEditor(this, props);
+    }
+}
+
 /**
  * @name plugins
  * @memberOf Hypergrid
diff --git a/src/behaviors/Behavior.js b/src/behaviors/Behavior.js
index 66d129eb0..517ec4d52 100644
--- a/src/behaviors/Behavior.js
+++ b/src/behaviors/Behavior.js
@@ -5,8 +5,10 @@ var Point = require('rectangular').Point;
 var Base = require('../Base');
 var Column = require('./Column');
 var cellEventFactory = require('../lib/cellEventFactory');
-var Features = require('../features');
+var featureRegistry = require('../features');
+var Synonomous = require('synonomous');
 var propClassEnum = require('../defaults.js').propClassEnum;
+var assignOrDelete = require('../lib/misc').assignOrDelete;
 
 
 var noExportProperties = [
@@ -42,6 +44,8 @@ var Behavior = Base.extend('Behavior', {
          */
         this.grid = grid;
 
+        this.synonomous = new Synonomous;
+
         this.initializeFeatureChain();
 
         this.grid.behavior = this;
@@ -72,7 +76,7 @@ var Behavior = Base.extend('Behavior', {
          */
         this.featureMap = {};
 
-        this.featureRegistry = this.featureRegistry || new Features;
+        this.featureRegistry = this.featureRegistry || featureRegistry;
 
         if (this.grid.properties.features) {
             var getFeatureConstructor = this.featureRegistry.get.bind(this.featureRegistry);
@@ -131,6 +135,9 @@ var Behavior = Base.extend('Behavior', {
 
         this.scrollPositionX = this.scrollPositionY = 0;
 
+        this.rowPropertiesPrototype = Object.create(this.grid.properties,
+            require('./rowProperties').rowPropertiesPrototypeDescriptors);
+
         this.clearColumns();
         this.createColumns();
 
@@ -235,15 +242,21 @@ var Behavior = Base.extend('Behavior', {
     },
 
     addColumn: function(options) {
-        var column = this.newColumn(options);
-        this.columns.push(column);
-        this.allColumns.push(column);
+        var column = this.newColumn(options),
+            columns = this.columns,
+            allColumns = this.allColumns;
+
+        columns.push(column);
+        this.synonomous.decorateList(columns.length - 1, columns);
+
+        allColumns.push(column);
+        this.synonomous.decorateList(allColumns.length - 1, allColumns);
+
         return column;
     },
 
     createColumns: function() {
         this.clearColumns();
-        this.clearAllCellProperties();
         //concrete implementation here
     },
 
@@ -325,58 +338,99 @@ var Behavior = Base.extend('Behavior', {
      * @desc clear all table state
      */
     clearState: function() {
-       this.grid.clearState();
+        this.grid.clearState();
+        this.createColumns();
     },
 
     /**
      * @memberOf Behavior#
      * @desc Restore this table to a previous state.
      * See the [memento pattern](http://c2.com/cgi/wiki?MementoPattern).
-     * @param {Object} memento - an encapsulated representation of table state
+     * @param {Object} properties - assignable grid properties
      */
-    setState: function(memento) {
+    setState: function(properties) {
+        this.addState(properties, true);
+    },
 
-        if (memento.rowHeights) {
-            this.deprecated('rowHeights', 'rowHeights, the hash of row heights you provided to setState method, is no longer supported as of v1.2.0 and will be ignored. Instead, for each row height you wish to set, use `rows: { subgrid: { y: { height: heightInPixels } } }` substituting the name (or type) of the subgrid for `subgrid`, the local zero-based rowIndex within the subgrid for `y`, and the row height in pixels for `heightInPixels`; or make individual calls to `setRowHeight(y, heightInPixels, dataModel)`. The dataModel arg is optional and defaults to this.dataModel (the data subgrid); specify to set row heights in other data models, such as header row, filter cell row, individual summary rows, etc.');
+    /**
+     *
+     * @param {Object} properties - assignable grid properties
+     * @param {boolean} [settingState] - Clear properties object before assignments.
+     */
+    addState: function(properties, settingState) {
+        if (settingState) {
+            this.clearState();
         }
 
-        this.createColumns();
+        var gridProps = this.grid.properties;
 
-        var state = this.grid.properties;
-        Object.keys(memento).forEach(function(key) {
-            state[key] = memento[key];
-        }, this);
+        gridProps.settingState = settingState;
+        assignOrDelete(gridProps, properties);
+        delete gridProps.settingState;
 
-        this.setAllColumnProperties(memento.columnProperties);
+        this.reindex();
+    },
 
-        this.dataModel.reindex();
+    /**
+     * @summary Sets properties for active columns.
+     * @desc Sets multiple columns' properties from elements of given array or collection. Keys may be column indexes or column names. The properties collection is cleared first. Falsy elements are ignored.
+     * @param {object[]|undefined} columnsHash - If undefined, this call is a no-op.
+     */
+    setAllColumnProperties: function(columnsHash) {
+        this.addAllColumnProperties(columnsHash, true);
     },
 
-    setAllColumnProperties: function(columnProperties) {
-        if (columnProperties) {
-            columnProperties.forEach(function(properties, i) {
-                this.getColumn(i).properties = properties;
-            }, this);
+    /**
+     * @summary Adds properties for multiple columns.
+     * @desc Adds . The properties collection is optionally cleared first. Falsy elements are ignored.
+     * @param {object[]|undefined} columnsHash - If undefined, this call is a no-op.
+     * @param {boolean} [settingState] - Clear columns' properties objects before copying properties.
+     */
+    addAllColumnProperties: function(columnsHash, settingState) {
+        if (!columnsHash) {
+            return;
         }
+
+        var columns = this.grid.behavior.getColumns();
+
+        Object.keys(columnsHash).forEach(function(key) {
+            var column = columns[key];
+            if (column) {
+                column.addProperties(columnsHash[key], settingState);
+            }
+        });
     },
 
     setColumnOrder: function(columnIndexes) {
         if (Array.isArray(columnIndexes)){
-            this.columns.length = columnIndexes.length;
-            columnIndexes.forEach(function(index, i) {
-                this.columns[i] = this.allColumns[index];
-            }, this);
+            var columns = this.columns,
+                allColumns = this.allColumns;
+
+            // avoid recreating the array to keep refs valid; just empty it (including name dictionary)
+            columns.length = 0;
+            var tc = this.treeColumnIndex.toString(), rc = this.rowColumnIndex.toString();
+            Object.keys(columns).forEach(function(key) {
+                switch (key) {
+                    case tc:
+                    case rc:
+                        break;
+                    default:
+                        delete columns[key];
+                }
+            });
+
+            columnIndexes.forEach(function(index) {
+                columns.push(allColumns[index]);
+            });
+
+            this.synonomous.decorateList(columns);
         }
     },
 
     setColumnOrderByName: function(columnNames) {
-        if (Array.isArray(columnNames)){
-            this.columns.length = columnNames.length;
-            columnNames.forEach(function(columnName, i) {
-                this.columns[i] = this.allColumns.find(function(column) {
-                    return column.name === columnName;
-                });
-            }, this);
+        if (Array.isArray(columnNames)) {
+            var allColumns = this.allColumns;
+            this.setColumnOrder(columnNames.map(function(name) { return allColumns[name].index; }));
         }
     },
 
@@ -717,104 +771,6 @@ var Behavior = Base.extend('Behavior', {
         return this.deprecated('getUnfilteredRowCount()', '', '1.2.0', arguments, 'No longer supported');
     },
 
-    /**
-     * @summary The total height of the "fixed rows."
-     * @desc The total height of all (non-scrollable) rows preceding the (scrollable) data subgrid.
-     * @memberOf Behavior#
-     * @return {number} The height in pixels of the fixed rows area of the hypergrid, the total height of:
-     * 1. All rows of all subgrids preceding the data subgrid.
-     * 2. The first `fixedRowCount` rows of the data subgrid.
-     */
-    getFixedRowsHeight: function() {
-        var dataModel, isData, r, R,
-            subgrids = this.subgrids,
-            height = 0;
-
-        for (var i = 0; i < subgrids.length && !isData; ++i) {
-            dataModel = subgrids[i];
-            isData = dataModel.isData;
-            R = isData ? this.grid.properties.fixedRowCount : dataModel.getRowCount();
-            for (r = 0; r < R; ++r) {
-                height += this.getRowHeight(r, dataModel);
-            }
-        }
-
-        return height;
-    },
-
-    /**
-     * @memberOf Behavior#
-     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
-     * @param {boolean} [properties] - New properties object when one does not already exist. If you don't provide this and one does not already exist, this call will return `undefined`. _(Required when 3rd param provided.)_
-     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
-     * @returns {object|undefined} The row properties object which will be one of:
-     * * The row properties object if it existed.
-     * * The value you provided in `properties` if the row properties for a new row properties object when the object did not already exist in the metadata
-     * * `undefined` if the row properties object did not exist _and_ you did not provide a value in `properties`.
-     */
-    getRowProperties: function(yOrCellEvent, properties, dataModel) {
-        if (typeof yOrCellEvent === 'object') {
-            dataModel = yOrCellEvent.subgrid;
-            yOrCellEvent = yOrCellEvent.dataCell.y;
-        }
-
-        var metadata = (dataModel || this.dataModel).getRowMetadata(yOrCellEvent, properties && {});
-        return metadata && (metadata.__ROW || properties && (metadata.__ROW = properties));
-    },
-
-    /**
-     * Reset the row properties in its entirety to the given row properties object.
-     * @memberOf Behavior#
-     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
-     * @param {object} properties - The new row properties object.
-     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
-     */
-    setRowProperties: function(yOrCellEvent, properties, dataModel) {
-        if (typeof yOrCellEvent === 'object') {
-            dataModel = yOrCellEvent.subgrid;
-            yOrCellEvent = yOrCellEvent.dataCell.y;
-        }
-
-        (dataModel || this.dataModel).getRowMetadata(yOrCellEvent, {}, dataModel).__ROW = properties;
-
-        this.stateChanged();
-    },
-
-    /**
-     * Sets a single row property on a specific individual row.
-     * @memberOf Behavior#
-     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
-     * @param {string} key - The property name.
-     * @param value - The new property value.
-     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
-     */
-    setRowProperty: function(yOrCellEvent, key, value, dataModel) {
-        this.getRowProperties(yOrCellEvent, {}, dataModel)[key] = value;
-        this.stateChanged();
-    },
-
-    /**
-     * Add all the properties in the given row properties object to the row properties.
-     * @memberOf Behavior#
-     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
-     * @param {object} properties - An object containing new property values(s) to assign to the row properties.
-     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
-     */
-    addRowProperties: function(yOrCellEvent, properties, dataModel) {
-        Object.assign(this.getRowProperties(yOrCellEvent, {}, dataModel), properties);
-        this.stateChanged();
-    },
-
-    /**
-     * @memberOf Behavior#
-     * @param {number} yOrCellEvent - Data row index local to `dataModel`.
-     * @param {dataModelAPI} [dataModel=this.dataModel]
-     */
-    getRowHeight: function(yOrCellEvent, dataModel) {
-        var rowProps = this.getRowProperties(yOrCellEvent, undefined, dataModel);
-        return rowProps && rowProps.height || this.grid.properties.defaultRowHeight;
-    },
-
     /**
      * @memberOf Behavior#
      * @desc The value is lazily initialized and comes from the properties mechanism for '`defaultRowHeight`', which should be ~20px.
@@ -824,24 +780,6 @@ var Behavior = Base.extend('Behavior', {
         return this.deprecated('getDefaultRowHeight()', 'grid.properties.defaultRowHeight', '1.2.0');
     },
 
-    /**
-     * @memberOf Behavior#
-     * @desc set the pixel height of a specific row
-     * @param {number} yOrCellEvent - Data row index local to dataModel.
-     * @param {number} height - pixel height
-     * @param {dataModelAPI} [dataModel=this.dataModel]
-     */
-    setRowHeight: function(yOrCellEvent, height, dataModel) {
-        var rowProps = this.getRowProperties(yOrCellEvent, {}, dataModel),
-            oldHeight = rowProps.height;
-
-        rowProps.height = Math.max(5, Math.ceil(height));
-
-        if (rowProps.height !== oldHeight) {
-            this.stateChanged();
-        }
-    },
-
     /**
      * @memberOf Behavior#
      * @return {number} The width of the fixed column area in the hypergrid.
@@ -1553,6 +1491,7 @@ Behavior.prototype.applyAnalytics = Behavior.prototype.reindex;
 
 // mix-ins
 Behavior.prototype.mixIn(require('./subgrids'));
+Behavior.prototype.mixIn(require('./rowProperties').mixin);
 
 
 module.exports = Behavior;
diff --git a/src/behaviors/Column.js b/src/behaviors/Column.js
index 56494e525..75fd34dd4 100644
--- a/src/behaviors/Column.js
+++ b/src/behaviors/Column.js
@@ -6,20 +6,28 @@ var overrider = require('overrider');
 
 var deprecated = require('../lib/deprecated');
 var toFunction = require('../lib/toFunction');
+var assignOrDelete = require('../lib/misc').assignOrDelete;
 var HypergridError = require('../lib/error');
-var images = require('../../images/index');
+var images = require('../../images');
+
+
+var warned = {};
 
 
 /** @summary Create a new `Column` object.
  * @see {@link module:Cell} is mixed into Column.prototype.
+ * @mixes cellProperties.columnMixin
+ * @mixes columnProperties.mixin
  * @constructor
- * @param behavior
- * @param {number|string|object} indexOrOptions - One of:
- * * If a positive number, valid index into `fields` array.
- * * If a string, a name in the `fields` array.
- * * If an object, must contain either an `index` or a `name` property.
+ * @param {Behavior} behavior
+ * @param {object} columnSchema
+ * @param {number} columnSchema.index
+ * @param {string} columnSchema.name
+ * @param {string} [columnSchema.header] - Displayed in column headers. If not defined, name is used.
+ * @param {function} [columnSchema.calculator] - Define to make a computed column.
+ * @param {string} [columnSchema.type] - For possible data model use. (Not used in core.)
  *
- * Positive values of `index` are "real" fields; see also {@link Column#setProperties|setProperties} which is called to set the remaining properties specified in `options`.
+ * Positive values of `index` are "real" fields.
  *
  * Negative values of `index` are special cases:
  * `index` | Meaning
@@ -27,55 +35,86 @@ var images = require('../../images/index');
  *    -1   | Row header column
  *    -2   | Tree (drill-down) column
  */
-function Column(behavior, indexOrOptions) {
-    var index, schema, options, icon;
-
-    this.behavior = behavior;
-    this.dataModel = behavior.dataModel;
-
-    schema = this.behavior.dataModel.schema;
-
-    switch (typeof indexOrOptions) {
+function Column(behavior, columnSchema) {
+    switch (typeof columnSchema) {
         case 'number':
-            index = indexOrOptions;
-            options = {};
+            if (!warned.number) {
+                console.warn('Column(behavior: object, index: number) overload has been deprecated as of v2.1.6 in favor of Column(behavior: object, columnSchema: object) overload with defined columnSchema.index. (Will be removed in a future release.)');
+                warned.number = true;
+            }
+            columnSchema = {
+                index: columnSchema
+            };
             break;
         case 'string':
-            index = getIndexFromName(indexOrOptions);
-            options = {};
+            if (!warned.string) {
+                console.warn('Column(behavior:object, name: string) overload (where name is sought in schema) has been deprecated as of v2.1.6 in favor of Column(behavior: object, columnSchema: object) overload with defined columnSchema.index. (Will be removed in a future release.)');
+                warned.string = true;
+            }
+            var name, index;
+            name = columnSchema;
+            index = behavior.dataModel.schema.findIndex(function(columnSchema) {
+                return columnSchema.name === name;
+            });
+            if (index < 0) {
+                throw new ReferenceError('Column named "' + name + '" not found in schema.');
+            }
+            columnSchema = {
+                name: name,
+                index: index
+            };
             break;
         case 'object':
-            options = indexOrOptions;
-            index = options.index !== undefined
-                ? options.index
-                : getIndexFromName(options.name);
+            if (columnSchema.index === undefined) {
+                if (!warned.object) {
+                    console.warn('Column(behavior:object, columnSchema: object) overload (where columnSchema.index is undefined but columnSchema.name is sought in schema) has been deprecated as of v2.1.6 in favor of defined columnSchema.index. (Will be removed in a future release.)');
+                    warned.object = true;
+                }
+                name = columnSchema.name;
+                index = behavior.dataModel.schema.findIndex(function(columnSchema) {
+                    return columnSchema.name === name;
+                });
+                if (index < 0) {
+                    throw new ReferenceError('Column named "' + name + '" not found in schema.');
+                }
+                columnSchema.index = index;
+            }
+            break;
     }
 
-    function getIndexFromName(name) {
-        return schema.findIndex(function(columnSchema, i) {
-            return columnSchema.name === name;
-        });
+    if (columnSchema.index === undefined) {
+        throw new HypergridError('Column index required.');
     }
 
-    if (index === undefined) {
-        throw 'Column not found in data.';
-    }
+    this.behavior = behavior;
+    this.dataModel = behavior.dataModel;
 
-    this._index = index;
+    // set `index` and `name` as read-only properties
+    Object.defineProperties(this, {
+        index: {
+            value: columnSchema.index
+        },
+        name: {
+            enumerable: true,
+            value: columnSchema.name || columnSchema.index.toString()
+        }
+    });
 
-    this.properties = options;
+    this.properties = this.schema = columnSchema; // see {@link Column#properties properties} setter
 
-    switch (index) {
+    switch (columnSchema.index) {
         case this.behavior.treeColumnIndex:
             // Width of icon + 3-pixel spacer (checked and unchecked should be same width)
-            icon = images[Object.create(this.properties.treeHeader, { isDataRow: { value: true } }).leftIcon];
+            var icon = images[Object.create(this.properties.treeHeader, { isDataRow: { value: true } }).leftIcon];
             this.properties.minimumColumnWidth = icon ? icon.width + 3 : 0;
             break;
+
         case this.behavior.rowColumnIndex:
             break;
+
         default:
-            if (index < 0) {
-                throw '`index` out of range';
+            if (columnSchema.index < 0) {
+                throw new RangeError('New column index ' + columnSchema.index + ' out of range.');
             }
     }
 }
@@ -93,39 +132,22 @@ Column.prototype = {
         return this.deprecated('set(options)', 'setProperties(options)', '1.2.0', arguments);
     },
 
-    /**
-     * @summary Index of this column in the `fields` array.
-     * @returns {number}
-     */
-    get index() { // read-only (no setter)
-        return this._index;
-    },
-
-    /**
-     * @summary Name of this column from the `fields` array.
-     * @returns {string|undefined} Returns `undefined` if the column is not in the schema (such as for handle column).
-     */
-    get name() { // read-only (no setter)
-        var columnSchema = this.dataModel.schema[this._index];
-        return columnSchema && columnSchema.name;
-    },
-
     /**
      * @summary Get or set the text of the column's header.
      * @desc The _header_ is the label at the top of the column.
      *
      * Setting the header updates both:
-     * * the `fields` (aka, header) array in the underlying data source; and
+     * * the `schema` (aka, header) array in the underlying data source; and
      * * the filter.
      * @type {string}
      */
-    set header(headerText) {
-        this.dataModel.schema[this.index].header = headerText;
-        this.dataModel.prop(null, this.index, 'header', headerText);
+    set header(header) {
+        this.schema.header = header;
+        this.dataModel.prop(null, this.index, 'header', header);
         this.behavior.grid.repaint();
     },
     get header() {
-        return this.dataModel.schema[this.index].header;
+        return this.schema.header;
     },
 
     /**
@@ -138,22 +160,14 @@ Column.prototype = {
      * @type {string}
      */
     set calculator(calculator) {
-        var schema = this.dataModel.schema;
-
         calculator = resolveCalculator.call(this, calculator);
-
-        if (calculator !== schema[this.index].calculator) {
-            if (calculator === undefined) {
-                delete schema[this.index].calculator;
-            } else {
-                schema[this.index].calculator = calculator;
-            }
-            this.behavior.prop(null, this.index, 'calculator', calculator);
-            this.behavior.applyAnalytics();
+        if (calculator !== this.schema.calculator) {
+            this.schema.calculator = calculator;
+            this.behavior.grid.reindex(); // deferred reindex as there may be several of these calls at instantiation
         }
     },
     get calculator() {
-        return this.dataModel.schema[this.index].calculator;
+        return this.schema.calculator;
     },
 
     /**
@@ -164,13 +178,13 @@ Column.prototype = {
      * @type {string}
      */
     set type(type) {
-        this._type = type;
+        this.schema.type = type;
         //TODO: This is calling reindex for every column during grid init. Maybe defer all reindex calls until after an grid 'ready' event
         this.dataModel.prop(null, this.index, 'type', type);
         this.behavior.reindex();
     },
     get type() {
-        return this._type;
+        return this.schema.type;
     },
 
     getUnfilteredValue: function(y) {
@@ -274,9 +288,25 @@ Column.prototype = {
     get properties() {
         return this._properties;
     },
-    set properties(ownProperties) {
-        this._properties = this.createColumnProperties();
-        this.addProperties(ownProperties);
+    set properties(properties) {
+        this.addProperties(properties, true);
+    },
+
+    /**
+     * Copy a properties collection to this column's properties object.
+     *
+     * When a value is `undefined` or `null`, the property is deleted except when a setter or non-configurable in which case it's set to `undefined`.
+     * @param {object|undefined} properties - Properties to copy to column's properties object. If `undefined`, this call is a no-op.
+     * @param {boolean} [settingState] - Clear column's properties object before copying properties.
+     */
+    addProperties: function(properties, settingState) {
+        if (!properties) {
+            return;
+        }
+        if (settingState || !this._properties) {
+            this._properties = this.createColumnProperties();
+        }
+        assignOrDelete(this._properties, properties);
     },
 
     getProperties: function() {
@@ -306,19 +336,6 @@ Column.prototype = {
         }
     },
 
-    addProperties: function(properties) {
-        var key, descriptor, obj = this.properties;
-
-        for (key in properties) {
-            if (properties.hasOwnProperty(key)) {
-                descriptor = Object.getOwnPropertyDescriptor(obj, key);
-                if (!descriptor || descriptor.writable || descriptor.set) {
-                    obj[key] = properties[key];
-                }
-            }
-        }
-    },
-
     /**
      * @summary Get a new cell editor.
      * @desc The cell editor to use must be registered with the key in the cell's `editor` property.
@@ -359,7 +376,9 @@ Column.prototype = {
     }
 };
 
-var REGEX_ARROW_FUNC = /^(\(.*\)|\w+)\s*=>/;
+var REGEX_ARROW_FUNC = /^(\(.*\)|\w+)\s*=>/,
+    REGEX_NAMED_FUNC = /^function\s+(\w+)\(/,
+    REGEX_ANON_FUNC = /^function\s*\(/;
 
 /**
  * Calculators are functions. Column calculators are saved in `grid.properties.calculators` using the function name as key. Anonymous functions use the stringified function itself as the key. This may seem pointless, but this achieves the objective here which is to share function instances.
@@ -379,10 +398,12 @@ function resolveCalculator(calculator) {
         return undefined;
     }
 
+    var forColumnName = ' (for column "' + this.name + '").';
+
     if (typeof calculator === 'function') {
         calculator = calculator.toString();
     } else if (typeof calculator !== 'string') {
-        throw new HypergridError('Expected function OR string containing function OR function name the "' + this.name + '" column calculator.');
+        throw new HypergridError('Expected calculator function OR string containing calculator function OR calculator name' + forColumnName);
     }
 
     var matches, key,
@@ -391,26 +412,22 @@ function resolveCalculator(calculator) {
     if (/^\w+$/.test(calculator)) {
         key = calculator; // just a function name
         if (!calculators[key]) {
-            throw new HypergridError('Unknown function name "' + key + '" for "' + this.name + '" column calculator.');
-        }
-    } else {
-        matches = calculator.match(/^function\s*(\w+)\(/);
-
-        if (matches) {
-            key = matches[1]; // function name extracted from stringified function
-        } else {
-            key = calculator; // anonymous stringified function
+            throw new HypergridError('Unknown calculator name "' + key + forColumnName);
         }
+    } else if ((matches = calculator.match(REGEX_NAMED_FUNC))) {
+        key = matches[1]; // function name extracted from stringified function
+    } else if (calculator.test(REGEX_ANON_FUNC)) {
+        key = calculator; // anonymous stringified function
+    } else if (REGEX_ARROW_FUNC.test(calculator)) {
+        throw new HypergridError('Arrow function not permitted as column calculator ' + forColumnName);
+    }
 
-        if (!calculators[key]) { // neither a string nor a function (previoulsy functionified string)?
-            if (REGEX_ARROW_FUNC.test(calculator)) {
-                throw new HypergridError('Arrow function not permitted as column calculator (for column "' + this.name + '").');
-            }
-            calculators[key] = calculator;
-        }
+    if (!calculators[key]) { // neither a string nor a function (previously functionified string)?
+        calculators[key] = calculator;
     }
 
-    calculators[key] = toFunction(calculators[key]); // functionifies existing `calculators` entries as well as new entries
+    // functionify existing entries as well as new `calculators` entries
+    calculators[key] = toFunction(calculators[key]);
 
     return calculators[key];
 }
diff --git a/src/behaviors/JSON.js b/src/behaviors/JSON.js
index eca2d621d..1535e9940 100644
--- a/src/behaviors/JSON.js
+++ b/src/behaviors/JSON.js
@@ -40,12 +40,11 @@ var JSON = Behavior.extend('behaviors.JSON', {
         });
 
         this.dataModel.schema.forEach(function(columnSchema, index) {
-            this.addColumn({
-                index: index,
-                header: columnSchema.header,
-                calculator: columnSchema.calculator
-            });
-
+            if (typeof columnSchema === 'string') {
+                this.dataModel.schema[index] = columnSchema = { name: columnSchema };
+            }
+            columnSchema.index = index;
+            this.addColumn(columnSchema);
             columnEnum[this.columnEnumKey(columnSchema.name)] = index;
         }, this);
     },
diff --git a/src/behaviors/cellProperties.js b/src/behaviors/cellProperties.js
index 113a7bcd7..2cbd049c1 100644
--- a/src/behaviors/cellProperties.js
+++ b/src/behaviors/cellProperties.js
@@ -2,6 +2,9 @@
 
 'use strict';
 
+var assignOrDelete = require('../lib/misc').assignOrDelete;
+
+
 /**
  * Column.js mixes this module into its prototype.
  * @module
@@ -23,23 +26,26 @@ var cell = {
 
     /**
      * @param {number} rowIndex - Data row coordinate.
-     * @param {Object} properties - Hash of cell properties.
+     * @param {object|undefined} properties - Hash of cell properties. If `undefined`, this call is a no-op.
      * @returns {*}
      * @memberOf Column#
      */
     setCellProperties: function(rowIndex, properties, dataModel) {
-        return Object.assign(newCellPropertiesObject.call(this, rowIndex, dataModel), properties);
+        if (properties) {
+            return assignOrDelete(newCellPropertiesObject.call(this, rowIndex, dataModel), properties);
+        }
     },
 
     /**
      * @param {number} rowIndex - Data row coordinate.
-     * @param {Object} properties - Hash of cell properties.
-     * @param {boolean} [preserve=false] - Falsy creates new object; truthy copies `properties` members into existing object.
-     * @returns {*}
+     * @param {object|undefined} properties - Hash of cell properties. If `undefined`, this call is a no-op.
+     * @returns {object} Cell's own properties object, which will be created by this call if it did not already exist.
      * @memberOf Column#
      */
     addCellProperties: function(rowIndex, properties, dataModel) {
-        return Object.assign(getCellPropertiesObject.call(this, rowIndex, dataModel), properties);
+        if (properties) {
+            return assignOrDelete(getCellPropertiesObject.call(this, rowIndex, dataModel), properties);
+        }
     },
 
     /**
diff --git a/src/behaviors/columnProperties.js b/src/behaviors/columnProperties.js
index 0f3cd3863..e00cca8e6 100644
--- a/src/behaviors/columnProperties.js
+++ b/src/behaviors/columnProperties.js
@@ -443,4 +443,4 @@ createColumnProperties.columnHeaderDescriptors = {
     rightIcon: { writable: true, value: undefined},
 };
 
-module.exports.createColumnProperties = createColumnProperties;
+exports.createColumnProperties = createColumnProperties;
diff --git a/src/behaviors/rowProperties.js b/src/behaviors/rowProperties.js
new file mode 100644
index 000000000..34a3b2cc2
--- /dev/null
+++ b/src/behaviors/rowProperties.js
@@ -0,0 +1,188 @@
+'use strict';
+
+exports.mixin = {
+    /**
+     * @summary The total height of the "fixed rows."
+     * @desc The total height of all (non-scrollable) rows preceding the (scrollable) data subgrid.
+     * @memberOf Behavior#
+     * @return {number} The height in pixels of the fixed rows area of the hypergrid, the total height of:
+     * 1. All rows of all subgrids preceding the data subgrid.
+     * 2. The first `fixedRowCount` rows of the data subgrid.
+     */
+    getFixedRowsHeight: function() {
+        var subgrid, isData, r, R,
+            subgrids = this.subgrids,
+            height = 0;
+
+        for (var i = 0; i < subgrids.length && !isData; ++i) {
+            subgrid = subgrids[i];
+            isData = subgrid.isData;
+            R = isData ? this.grid.properties.fixedRowCount : subgrid.getRowCount();
+            for (r = 0; r < R; ++r) {
+                height += this.getRowHeight(r, subgrid);
+            }
+        }
+
+        return height;
+    },
+
+    /**
+     * @memberOf Behavior#
+     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
+     * @param {boolean} [prototype] - Prototype for a new properties object when one does not already exist. If you don't define this and one does not already exist, this call will return `undefined`.
+     * Typical defined value is `null`, which creates a plain object with no prototype, or `Object.prototype` for a more "natural" object.
+     * _(Required when 3rd param provided.)_
+     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
+     * @returns {object|undefined} The row properties object which will be one of:
+     * * object - existing row properties object or new row properties object created from `prototype`; else
+     * * `false` - row found but no existing row properties object and `prototype` was not defined; else
+     * * `undefined` - no such row
+     */
+    getRowProperties: function(yOrCellEvent, prototype, dataModel) {
+        if (typeof yOrCellEvent === 'object') {
+            dataModel = yOrCellEvent.subgrid;
+            yOrCellEvent = yOrCellEvent.dataCell.y;
+        }
+
+        var metadata = (dataModel || this.dataModel).getRowMetadata(yOrCellEvent, prototype === undefined ? undefined : null);
+        return metadata && (metadata.__ROW || prototype !== undefined && (metadata.__ROW = Object.create(prototype)));
+    },
+
+    /**
+     * Reset the row properties in its entirety to the given row properties object.
+     * @memberOf Behavior#
+     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
+     * @param {object|undefined} properties - The new row properties object. If `undefined`, this call is a no-op.
+     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
+     */
+    setRowProperties: function(yOrCellEvent, properties, dataModel) {
+        if (!properties) {
+            return;
+        }
+
+        if (typeof yOrCellEvent === 'object') {
+            dataModel = yOrCellEvent.subgrid;
+            yOrCellEvent = yOrCellEvent.dataCell.y;
+        }
+
+        var metadata = (dataModel || this.dataModel).getRowMetadata(yOrCellEvent, null);
+        if (metadata) {
+            metadata.__ROW = Object.create(this.rowPropertiesPrototype);
+            this.addRowProperties(yOrCellEvent, properties, dataModel, metadata.__ROW);
+        }
+    },
+
+    /**
+     * Sets a single row property on a specific individual row.
+     * @memberOf Behavior#
+     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
+     * @param {string} key - The property name.
+     * @param value - The new property value.
+     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
+     */
+    setRowProperty: function(yOrCellEvent, key, value, dataModel) {
+        var rowProps;
+        var isHeight = (key === 'height');
+
+        if (value !== undefined) {
+            rowProps = this.getRowProperties(yOrCellEvent, this.rowPropertiesPrototype, dataModel);
+            rowProps[key] = value;
+        } else {
+            // only try to undefine key if row props object exists; no point in creating it just to delete a non-existant key
+            rowProps = this.getRowProperties(yOrCellEvent, undefined, dataModel);
+            if (rowProps) {
+                delete rowProps[isHeight ? '_height' : key];
+            }
+        }
+
+        if (isHeight) {
+            this.shapeChanged();
+        } else {
+            this.stateChanged();
+        }
+    },
+
+    /**
+     * Add all the properties in the given row properties object to the row properties.
+     * @memberOf Behavior#
+     * @param {number|CellEvent} yOrCellEvent - Data row index local to `dataModel`; or a `CellEvent` object.
+     * @param {object|undefined} properties - An object containing new property values(s) to assign to the row properties. If `undefined`, this call is a no-op.
+     * @param {dataModelAPI} [dataModel=this.dataModel] - This is the subgrid. You only need to provide the subgrid when it is not the data subgrid _and_ you did not give a `CellEvent` object in the first param (which already knows what subgrid it's in).
+     */
+    addRowProperties: function(yOrCellEvent, properties, dataModel, rowProps) {
+        if (!properties) {
+            return;
+        }
+
+        var isHeight, hasHeight;
+
+        rowProps = rowProps || this.getRowProperties(yOrCellEvent, this.rowPropertiesPrototype, dataModel);
+
+        if (rowProps) {
+            Object.keys(properties).forEach(function(key) {
+                var value = properties[key];
+                if (value !== undefined) {
+                    rowProps[key] = value;
+                } else {
+                    isHeight = key === 'height';
+                    delete rowProps[isHeight ? '_height' : key];
+                    hasHeight = hasHeight || isHeight;
+                }
+            });
+
+            if (hasHeight) {
+                this.shapeChanged();
+            } else {
+                this.stateChanged();
+            }
+        }
+    },
+
+    /**
+     * @memberOf Behavior#
+     * @param {number} yOrCellEvent - Data row index local to `dataModel`.
+     * @param {dataModelAPI} [dataModel=this.dataModel]
+     * @returns {number} The row height in pixels.
+     */
+    getRowHeight: function(yOrCellEvent, dataModel) {
+        var rowProps = this.getRowProperties(yOrCellEvent, undefined, dataModel);
+        return rowProps && rowProps.height || this.grid.properties.defaultRowHeight;
+    },
+
+    /**
+     * @memberOf Behavior#
+     * @desc set the pixel height of a specific row
+     * @param {number} yOrCellEvent - Data row index local to dataModel.
+     * @param {number} height - pixel height
+     * @param {dataModelAPI} [dataModel=this.dataModel]
+     */
+    setRowHeight: function(yOrCellEvent, height, dataModel) {
+        this.setRowProperty(yOrCellEvent, 'height', height, dataModel);
+    }
+};
+
+
+exports.rowPropertiesPrototypeDescriptors = {
+    height: {
+        enumerable: true,
+        get: function() {
+            return this._height || this.defaultRowHeight;
+        },
+        set: function(height) {
+            height = Math.max(5, Math.ceil(height));
+            if (isNaN(height)) {
+                height = undefined;
+            }
+            if (height !== this._height) {
+                if (!height) {
+                    delete this._height;
+                } else {
+                    // Define `_height` as non-enumerable so won't be included in output of saveState.
+                    // (Instead the `height` getter is explicitly invoked and the result is included.)
+                    Object.defineProperty(this, '_height', { value: height, configurable: true });
+                }
+                this.grid.behaviorStateChanged();
+            }
+        }
+    }
+};
diff --git a/src/cellEditors/index.js b/src/cellEditors/index.js
index 8574331bc..1e359423b 100644
--- a/src/cellEditors/index.js
+++ b/src/cellEditors/index.js
@@ -3,53 +3,42 @@
 var Registry = require('../lib/Registry');
 
 
-var deprecated = {
-    celleditor: undefined,
-    CellEditor: undefined
-};
-
+var warnedBaseClass;
 
 /**
  * @classdesc Registry of cell editor constructors.
- * @param {Hypergrid} options.grid
- * @param {boolean} [options.private=false] - This instance will use a private registry.
  * @constructor
  */
 var CellEditors = Registry.extend('CellEditors', {
 
     BaseClass: require('./CellEditor'), // abstract base class
 
-    items: {}, // shared cell editor registry (when !options.private)
-
-    initialize: function(options) {
+    initialize: function() {
         // preregister the standard cell editors
-        if (options && options.private || !this.items.celleditor) {
-            this.add(require('./Color'));
-            this.add(require('./Date'));
-            this.add(require('./Number'));
-            this.add(require('./Slider'));
-            this.add(require('./Spinner'));
-            this.add(require('./Textfield'));
-        }
-    },
-
-    construct: function(Constructor, options) {
-        return new Constructor(this.options.grid, options);
+        this.add(require('./Color'));
+        this.add(require('./Date'));
+        this.add(require('./Number'));
+        this.add(require('./Slider'));
+        this.add(require('./Spinner'));
+        this.add(require('./Textfield'));
     },
 
     get: function(name) {
-        if (name in deprecated) {
-            if (!deprecated.warned) {
+        if (name && name.toLowerCase() === 'celleditor') {
+            if (!warnedBaseClass) {
                 console.warn('grid.cellEditors.get("' + name + '") method call has been deprecated as of v2.1.0 in favor of grid.cellEditors.BaseClass property. (Will be removed in a future release.)');
-                deprecated.warned = true;
+                warnedBaseClass = true;
             }
             return this.BaseClass;
         }
-        return this.super.get.call(this, name, true);
+        try {
+            var CellEditor = Registry.prototype.get.call(this, name);
+        } catch (err) {
+            // fail silently
+        }
+        return CellEditor;
     }
 
 });
 
-CellEditors.add = Registry.prototype.add.bind(CellEditors);
-
-module.exports = CellEditors;
+module.exports = new CellEditors;
diff --git a/src/cellRenderers/index.js b/src/cellRenderers/index.js
index 14bc2e56a..e931bf773 100644
--- a/src/cellRenderers/index.js
+++ b/src/cellRenderers/index.js
@@ -3,53 +3,50 @@
 var Registry = require('../lib/Registry');
 
 
-var deprecated = {
-    emptycell: undefined,
-    EmptyCell: undefined
-};
-
+var warnedBaseClass;
 
 /**
  * @classdesc Registry of cell renderer singletons.
- * @param {boolean} [privateRegistry=false] - This instance will use a private registry.
  * @constructor
  */
 var CellRenderers = Registry.extend('CellRenderers', {
 
     BaseClass: require('./CellRenderer'), // abstract base class
 
-    items: {}, // shared cell renderer registry (when !options.private)
-
-    singletons: true,
-
-    initialize: function(options) {
+    initialize: function() {
         // preregister the standard cell renderers
-        if (options && options.private || !this.items.simplecell) {
-            this.add(require('./Button'));
-            this.add(require('./SimpleCell'));
-            this.add(require('./SliderCell'));
-            this.add(require('./SparkBar'));
-            this.add(require('./LastSelection'));
-            this.add(require('./SparkLine'));
-            this.add(require('./ErrorCell'));
-            this.add(require('./TreeCell'));
+        this.add(require('./Button'));
+        this.add(require('./SimpleCell'));
+        this.add(require('./SliderCell'));
+        this.add(require('./SparkBar'));
+        this.add(require('./LastSelection'));
+        this.add(require('./SparkLine'));
+        this.add(require('./ErrorCell'));
+        this.add(require('./TreeCell'));
+    },
+
+    // for better performance, instantiate at add time rather than render time.
+    add: function(name, Constructor) {
+        if (arguments.length === 1) {
+            Constructor = name;
+            return Registry.prototype.add.call(this, new Constructor);
+        } else {
+            return Registry.prototype.add.call(this, name, new Constructor);
         }
     },
 
     get: function(name) {
-        if (name in deprecated) {
-            if (!deprecated.warned) {
+        if (name && name.toLowerCase() === 'emptycell') {
+            if (!warnedBaseClass) {
                 console.warn('grid.cellRenderers.get("' + name + '").constructor has been deprecated as of v2.1.0 in favor of grid.cellRenderers.BaseClass property. (Will be removed in a future release.)');
-                deprecated.warned = true;
+                warnedBaseClass = true;
             }
             this.BaseClass.constructor = this.BaseClass;
             return this.BaseClass;
         }
-        return this.super.get.call(this, name);
+        return Registry.prototype.get.call(this, name);
     }
 
 });
 
-CellRenderers.add = Registry.prototype.add.bind(CellRenderers);
-
-module.exports = CellRenderers;
+module.exports = new CellRenderers;
diff --git a/src/dataModels/DataModel.js b/src/dataModels/DataModel.js
index fa035242f..4330bfe71 100644
--- a/src/dataModels/DataModel.js
+++ b/src/dataModels/DataModel.js
@@ -19,14 +19,21 @@ var DataModel = Base.extend('DataModel', {
         return this.deprecated('getPrivateState()', 'grid.properties', '1.2.0');
     },
 
-    getRowMetadata: function(rowIndex, metadata) {
+    getRowMetadata: function(rowIndex, prototype) {
         var dataRow = this.getRow(rowIndex);
-        return dataRow && (dataRow.__META || (dataRow.__META = metadata));
+        return dataRow && (dataRow.__META || (prototype !== undefined && (dataRow.__META = Object.create(prototype))));
     },
 
     setRowMetadata: function(rowIndex, metadata) {
         var dataRow = this.getRow(rowIndex);
-        return dataRow && (dataRow.__META = metadata);
+        if (dataRow) {
+            if (metadata) {
+                dataRow.__META = metadata;
+            } else {
+                delete dataRow.__META;
+            }
+        }
+        return !!dataRow;
     },
 
     /**
diff --git a/src/defaults.js b/src/defaults.js
index 39e4ed5d4..9ae421373 100644
--- a/src/defaults.js
+++ b/src/defaults.js
@@ -1092,10 +1092,9 @@ var defaults = {
     autoSelectColumns: false,
 
     /** @summary Name of a formatter for cell text.
-     * @desc The default (`undefined`) falls back to `column.type`.
-     * The value `null` does no formatting.
+     * @desc Unknown formatter falls back to the `string` formatter (simple conversion to string with `+ ''`).
      * @default undefined
-     * @type {undefined|null|string}
+     * @type {string}
      * @memberOf module:defaults
      * @tutorial localization
      */
@@ -1104,7 +1103,7 @@ var defaults = {
     /** @summary Name of a cell editor from the {@link module:cellEditors|cellEditors API}..
      * @desc Not editable if named editor is does not exist.
      * @default undefined
-     * @type {undefined|null|string}
+     * @type {string}
      * @memberOf module:defaults
      * @tutorial cell-editors
      */
diff --git a/src/features/index.js b/src/features/index.js
index 095701140..cec153d5e 100644
--- a/src/features/index.js
+++ b/src/features/index.js
@@ -12,36 +12,30 @@ var Features = Registry.extend('Features', {
 
     BaseClass: require('./Feature'), // abstract base class
 
-    items: {}, // shared feature registry (when !options.private)
-
-    initialize: function(options) {
+    initialize: function() {
         // preregister the standard cell renderers
-        if (options && options.private || !this.items.cellclick) {
-            this.add(require('./CellClick'));
-            this.add(require('./CellEditing'));
-            this.add(require('./CellSelection'));
-            this.add(require('./ColumnMoving'));
-            this.add(require('./ColumnResizing'));
-            this.add(require('./ColumnSelection'));
-            this.add(require('./ColumnSorting'));
-            this.add(require('./Filters'));
-            this.add(require('./KeyPaging'));
-            this.add(require('./OnHover'));
-            // this.add(require('./RowResizing'));
-            this.add(require('./RowSelection'));
-            this.add(require('./ThumbwheelScrolling'));
-        }
+        this.add(Features.CellClick);
+        this.add(Features.CellEditing);
+        this.add(Features.CellSelection);
+        this.add(Features.ColumnMoving);
+        this.add(Features.ColumnResizing);
+        this.add(Features.ColumnSelection);
+        this.add(Features.ColumnSorting);
+        this.add(Features.Filters);
+        this.add(Features.KeyPaging);
+        this.add(Features.OnHover);
+        // this.add(require('./RowResizing'));
+        this.add(Features.RowSelection);
+        this.add(Features.ThumbwheelScrolling);
     }
 
 });
 
-Features.add = Registry.prototype.add.bind(Features);
-
 
 // Following shared props provided solely in support of build file usage, e.g., `fin.Hypergrid.features.yada`,
-// and are not meant to be used elsewhere.
+// presumably for overriding built-in features, and are not meant to be used elsewhere.
 
-Features.Feature = require('./Feature'); // abstract base class
+Features.BaseClass = require('./Feature'); // abstract base class
 Features.CellClick = require('./CellClick');
 Features.CellEditing = require('./CellEditing');
 Features.CellSelection = require('./CellSelection');
@@ -57,4 +51,4 @@ Features.RowSelection = require('./RowSelection');
 Features.ThumbwheelScrolling = require('./ThumbwheelScrolling');
 
 
-module.exports = Features;
+module.exports = new Features;
diff --git a/src/lib/Registry.js b/src/lib/Registry.js
index 6ead550e5..056f7e4f4 100644
--- a/src/lib/Registry.js
+++ b/src/lib/Registry.js
@@ -4,51 +4,41 @@ var Base = require('../Base');
 
 /**
  * @class
- * @param {object} [options] - The following options can alternatively be set in the prototype of an extending class.
- * @param {boolean} [options.singletons=false] - The registry will consist of singletons which will be instantiated as they are added.
- * (Otherwise the registry consists of constructors which are instantiated later on as needed.)
- * @param {boolean} [options.private=false] - This instance will use a private registry.
  */
 var Registry = Base.extend('Registry', {
-    initialize: function(options) {
-        this.options = options;
-
-        if (this.option('private')) {
-            this.items = Object.create(this.items);
-        }
-    },
-
-    option: function(key) {
-        return this.options && key in this.options ? this.options[key] : this[key];
+    initialize: function() {
+        this.items = Object.create(null);
     },
 
     /**
-     * @summary Register and instantiate a singleton.
+     * @summary Register an item and return it.
      * @desc Adds an item to the registry using the provided name (or the class name), converted to all lower case.
-     * @param {string} [name] - Case-insensitive item key. If not given, `Constructor.prototype.$$CLASS_NAME` is used.
-     * @param {function} Constructor
+     * @param {string} [name] - Case-insensitive item key. If not given, fallsback to `item.prototype.$$CLASS_NAME` or `item.prototype.name` or `item.name`.
+     * @param [item] - If unregistered or omitted, nothing is added and method returns `undefined`.
      *
      * > Note: `$$CLASS_NAME` is normally set by providing a string as the (optional) first parameter (`alias`) in your {@link https://www.npmjs.com/package/extend-me|extend} call.
      *
-     * @returns {function|Constructor} A newly registered item, either `Constructor` or singleton created by `new Constructor`.
+     * @returns Newly registered item or `undefined` if unregistered.
      *
      * @memberOf Registry#
      */
-    add: function(name, Constructor) {
-        if (typeof name === 'function') {
-            Constructor = name;
+    add: function(name, item) {
+        if (arguments.length === 1) {
+            item = name;
             name = undefined;
         }
 
-        name = name || Constructor.prototype.$$CLASS_NAME || Constructor.name; // try Funciton.prototype.name as last resort
+        if (!item) {
+            return;
+        }
+
+        name = name || item.getClassName && item.getClassName();
 
         if (!name) {
-            throw new this.HypergridError('Expected a registration name.');
+            throw new this.HypergridError('Cannot register ' + this.friendlyName() + ' without a name.');
         }
 
-        name = name.toLowerCase();
-
-        return (this.items[name] = this.option('singletons') ? this.construct(Constructor) : Constructor);
+        return (this.items[name] = item);
     },
 
     /**
@@ -63,13 +53,12 @@ var Registry = Base.extend('Registry', {
     },
 
     /**
-     * Fetch a registered singleton.
+     * Fetch a registered item.
      * @param {string} [name]
-     * @param {boolean} [noThrow] - Avoid throwing error if no such item; just return `undefined`.
-     * @returns {function|Constructor|undefined} A registered constructor item or `undefined` if none such.
+     * @returns {*|undefined} A registered item or `undefined` if unregistered.
      * @memberOf Registry#
      */
-    get: function(name, noThrow) {
+    get: function(name) {
         if (!name) {
             return;
         }
@@ -77,46 +66,53 @@ var Registry = Base.extend('Registry', {
         var result = this.items[name]; // for performance reasons, do not convert to lower case
 
         if (!result) {
-            var lowerName = name.toLowerCase();
-            result = this.items[lowerName]; // name may differ in case only
+            var lowerName = name.toLowerCase(); // name may differ in case only
+            var foundName = Object.keys(this.items).find(function(key) { return lowerName === key.toLowerCase(); });
+
+            result = this.items[foundName];
+
             if (result) {
-                this.addSynonym(name, lowerName); // register found name as a synonym for faster access next time around to avoid converting to lower case again
+                // Register name as a synonym for the found name for faster access next
+                // time without having to convert to lower case on every get.
+                this.addSynonym(name, foundName);
+            } else {
+                throw new this.HypergridError('Expected "' + name + '" to be a case-insensitive match for a registered ' + this.friendlyName() + '.');
             }
         }
 
-        if (!noThrow && !result) {
-            var classDesc = this.BaseClass.$$CLASS_NAME.replace(/([A-Z])/g, ' $1').trim().toLowerCase();
-            throw new this.HypergridError('Expected "' + name + '" to be a registered ' + classDesc + '.');
-        }
-
         return result;
     },
 
-    /**
-     * @summary Lookup registered item and return a new instance thereof.
-     * @returns New instance of the named constructor or `undefined` if none such.
-     * @param {string} name - Name of a registered item.
-     * @param {string} [options] - Properties to add to the instantiated item primarily for `mustache` use.
-     * @memberOf Registry#
-     */
-    create: function(name, options) {
-        var Constructor = this.get(name);
-
-        if (typeof Constructor !== 'function') {
-            return;
+    friendlyName: function() {
+        if (this.BaseClass) {
+            var name = this.BaseClass.getClassName();
+            name = name && name.replace(/([A-Z])/g, ' $1').trim().toLowerCase();
+        } else {
+            name = singularOf(this.getClassName()).toLowerCase();
         }
+        name = name || 'item';
+        return indefArtOf(name) + ' ' + name;
+    }
+});
 
-        if (Constructor.abstract) {
-            throw new this.HypergridError('Attempt to instantiate the abstract "' + name + '" class.');
-        }
+var endings = [
+    { plural: /ies$/, singular: 'y' },
+    { plural: /s$/, singular: '' }
+];
 
-        return this.construct(Constructor, options);
-    },
+function singularOf(name) {
+    endings.find(function(ending) {
+        if (ending.plural.test(name)) {
+            name = name.replace(ending.plural, ending.singular);
+            return true;
+        }
+    });
+    return name;
+}
 
-    construct: function(Constructor, options) {
-        return new Constructor(Object.assign({}, this.options, options));
-    }
-});
+function indefArtOf(name) {
+    return /^[aeiou]/.test(name) ? 'an' : 'a';
+}
 
 
 module.exports = Registry;
diff --git a/src/lib/cellEventFactory.js b/src/lib/cellEventFactory.js
index 62facdb96..019ed8e70 100644
--- a/src/lib/cellEventFactory.js
+++ b/src/lib/cellEventFactory.js
@@ -111,17 +111,17 @@ factory.cellEventProperties = Object.defineProperties({}, {
     rowOwnProperties: {
         // undefined return means there is no row properties object
         get: function() {
-            return this.behavior.getRowProperties(this);
+            return this.behavior.getRowProperties(this, undefined, this.subgrid);
         }
     },
     rowProperties: {
         get: function() {
             // use carefully! creates new object as needed; only use when object definitely needed: for setting prop with `.rowProperties[key] = value` or `Object.assign(.rowProperties, {...})`; use getRowProperty(key) instead for getting a property that may not exist because it will not create a new object
-            return this.behavior.getRowProperties(this, {});
+            return this.behavior.getRowProperties(this, null, this.subgrid);
         },
         set: function(properties) {
             // for resetting whole row properties object: `.rowProperties = {...}`
-            this.behavior.setRowProperties(this, properties); // calls `stateChanged()`
+            this.behavior.setRowProperties(this, properties, this.subgrid); // calls `stateChanged()`
         }
     },
     getRowProperty: { value: function(key) {
diff --git a/src/lib/deprecated.js b/src/lib/deprecated.js
index fe464f8a7..c8282e842 100644
--- a/src/lib/deprecated.js
+++ b/src/lib/deprecated.js
@@ -8,7 +8,7 @@ if (!console.warn) {
     };
 }
 
-var regexIsMethod = /^\w+\(.*\)$/;
+var regexIsMethod = /^[\w\.]+\(.*\)$/;
 
 /**
  * User is warned and new property is returned or new method is called and the result is returned.
@@ -44,7 +44,7 @@ var deprecated = function(methodName, dotProps, since, args, notes) {
         } else if (warned[methodName]) {
             --warned[methodName];
             memberType = regexIsMethod.test(dotProps) ? 'method' : 'property';
-            warning = 'The .' + methodName + ' method is deprecated as of v' + since +
+            warning = 'The .' + methodName + ' method has been deprecated as of v' + since +
                 ' in favor of the .' + chain.join('.') + ' ' + memberType + '.' +
                 ' (Will be removed in a future release.)';
 
diff --git a/src/lib/dynamicProperties.js b/src/lib/dynamicProperties.js
index ac4aad59e..c542f7264 100644
--- a/src/lib/dynamicProperties.js
+++ b/src/lib/dynamicProperties.js
@@ -130,10 +130,10 @@ var dynamicPropertyDescriptors = {
      */
     columns: {
         enumerable: true,
-        get: getColumnPropertiesByColumnName,
+        get: getColumnPropertiesByColumnIndexOrName,
         set: function(columnsHash) {
             if (columnsHash) {
-                setColumnPropertiesByColumnName.call(this, columnsHash);
+                setColumnPropertiesByColumnIndexOrName.call(this, columnsHash);
                 this.grid.behavior.changed();
             }
         }
@@ -231,52 +231,59 @@ var dynamicPropertyDescriptors = {
     gridBorderBottom: getGridBorderDescriptor('Bottom')
 };
 
+/**
+ * @name module:dynamicPropertyDescriptors.columnProperties
+ */
+dynamicPropertyDescriptors.columnProperties = dynamicPropertyDescriptors.columns;
+
+
 function getRowPropertiesBySubgridAndRowIndex() { // to be called with grid.properties as context
     var subgrids = {};
     var behavior = this.grid.behavior;
+    var defaultRowHeight = this.grid.properties.defaultRowHeight;
     behavior.subgrids.forEach(function(dataModel) {
         var key = dataModel.name || dataModel.type;
         for (var rowIndex = 0, rowCount = dataModel.getRowCount(); rowIndex < rowCount; ++rowIndex) {
             var rowProps = behavior.getRowProperties(rowIndex, undefined, dataModel);
             if (rowProps) {
-                var subgrid = subgrids[key] = subgrids[key] || {};
-                subgrid[rowIndex] = rowProps;
+                // create height mixin by invoking `height` getter
+                var height = { height: rowProps.height };
+                if (height.height === defaultRowHeight) {
+                    height = undefined;
+                }
+
+                // clone it and mix in height
+                rowProps = Object.assign({}, rowProps, height);
+
+                // only include if at least one defined prop
+                if (Object.getOwnPropertyNames(rowProps).find(definedProp)) {
+                    var subgrid = subgrids[key] || (subgrids[key] = {});
+                    subgrid[rowIndex] = rowProps;
+                }
             }
         }
+        function definedProp(key) { return rowProps[key] !== undefined; }
     });
     return subgrids;
 }
 
 function setRowPropertiesBySubgridAndRowIndex(rowsHash) { // to be called with grid.properties as context
-    var behavior = this.grid.behavior;
-    for (var subgridName in rowsHash) {
-        if (rowsHash.hasOwnProperty(subgridName)) {
-            var subgrid = behavior.subgrids.lookup[subgridName];
-            if (subgrid) {
-                var subgridHash = rowsHash[subgridName];
-                for (var rowIndex in subgridHash) {
-                    if (subgridHash.hasOwnProperty(rowIndex)) {
-                        var properties = subgridHash[rowIndex];
-                        for (var propName in properties) {
-                            if (properties.hasOwnProperty(propName)) {
-                                var propValue = properties[propName];
-                                switch (propName) {
-                                    case 'height':
-                                        behavior.setRowHeight(rowIndex, Number(propValue), subgrid);
-                                        break;
-                                    default:
-                                        console.warn('Unexpected row property "' + propName + '" ignored. (The only row property currently implemented is "height").');
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+    var behavior = this.grid.behavior,
+        methodName = this.settingState ? 'setRowProperties' : 'addRowProperties';
+
+    Object.keys(rowsHash).forEach(function(subgridName) {
+        var subgrid = behavior.subgrids.lookup[subgridName];
+        if (subgrid) {
+            var subgridHash = rowsHash[subgridName];
+            Object.keys(subgridHash).forEach(function(rowIndex) {
+                var properties = subgridHash[rowIndex];
+                behavior[methodName](rowIndex, properties, subgrid);
+            });
         }
-    }
+    });
 }
 
-function getColumnPropertiesByColumnName() { // to be called with grid.properties as context
+function getColumnPropertiesByColumnIndexOrName() { // to be called with grid.properties as context
     var columns = this.grid.behavior.getColumns(),
         headerify = this.grid.headerify;
     return columns.reduce(function(obj, column) {
@@ -290,10 +297,7 @@ function getColumnPropertiesByColumnName() { // to be called with grid.propertie
                     }
                     // fallthrough
                 default:
-                    var value = column.properties[key];
-                    if (value !== undefined) {
-                        properties[key] = value;
-                    }
+                    properties[key] = column.properties[key];
             }
             return properties;
         }, {});
@@ -304,21 +308,8 @@ function getColumnPropertiesByColumnName() { // to be called with grid.propertie
     }, {});
 }
 
-function setColumnPropertiesByColumnName(columnsHash) { // to be called with grid.properties as context
-    var columns = this.grid.behavior.getColumns();
-
-    for (var columnName in columnsHash) {
-        if (columnsHash.hasOwnProperty(columnName)) {
-            var column = columns.find(nameMatches);
-            if (column) {
-                column.properties = columnsHash[columnName];
-            }
-        }
-    }
-
-    function nameMatches(column) {
-        return column.name === columnName;
-    }
+function setColumnPropertiesByColumnIndexOrName(columnsHash) { // to be called with grid.properties as context
+    this.grid.behavior.addAllColumnProperties(columnsHash, this.settingState);
 }
 
 function getCellPropertiesByColumnNameAndRowIndex() {
@@ -348,34 +339,29 @@ function getCellPropertiesByColumnNameAndRowIndex() {
 
 function setCellPropertiesByColumnNameAndRowIndex(cellsHash) { // to be called with grid.properties as context
     var subgrids = this.grid.behavior.subgrids,
-        columns = this.grid.behavior.getColumns();
-
-    for (var subgridName in cellsHash) {
-        if (cellsHash.hasOwnProperty(subgridName)) {
-            var subgrid = subgrids.lookup[subgridName];
-            if (subgrid) {
-                var subgridHash = cellsHash[subgridName];
-                for (var rowIndex in subgridHash) {
-                    if (subgridHash.hasOwnProperty(rowIndex)) {
-                        var columnProps = subgridHash[rowIndex];
-                        for (var columnName in columnProps) {
-                            if (columnProps.hasOwnProperty(columnName)) {
-                                var column = columns.find(nameMatches);
-                                if (column) {
-                                    var properties = columnProps[columnName];
-                                    column.addCellProperties(rowIndex, properties, subgrid);
-                                }
-                            }
+        columns = this.grid.behavior.getColumns(),
+        methodName = this.settingState ? 'setCellProperties' : 'addCellProperties';
+
+    Object.keys(cellsHash).forEach(function(subgridName) {
+        var subgrid = subgrids.lookup[subgridName];
+        if (subgrid) {
+            var subgridHash = cellsHash[subgridName];
+            Object.keys(subgridHash).forEach(function(rowIndex) {
+                var columnProps = subgridHash[rowIndex];
+                Object.keys(columnProps).forEach(function(columnName) {
+                    var properties = columnProps[columnName];
+                    if (properties) {
+                        var column = columns.find(function(column) {
+                            return column.name === columnName;
+                        });
+                        if (column) {
+                            column[methodName](rowIndex, properties, subgrid);
                         }
                     }
-                }
-            }
+                });
+            });
         }
-    }
-
-    function nameMatches(column) {
-        return column.name === columnName;
-    }
+    });
 }
 
 function getGridBorderDescriptor(edge) {
diff --git a/src/lib/fields.js b/src/lib/fields.js
index 5aeccb7c3..c941d2c86 100644
--- a/src/lib/fields.js
+++ b/src/lib/fields.js
@@ -5,47 +5,23 @@
  * @module
  */
 
-var REGEXP_META_PREFIX = /^__/, // starts with double underscore
-    REGEXP_WORD_SEPARATORS = /[\s\-_]*([^\s\-_])([^\s\-_]+)/g,
-    REGEXP_CAPITAL_LETTERS = /[A-Z]/g,
-    REGEXP_LOWER_CASE_LETTER = /[a-z]/;
+var REGEXP_META_PREFIX = /^__/; // starts with double underscore
 
 /**
  * @param {object} hash
  * @returns {string[]} Member names from `hash` that do _not_ begin with double-underscore.
  * @memberOf module:fields
  */
-function getFieldNames(hash) {
+exports.getFieldNames = function(hash) {
     return Object.keys(hash || []).filter(function(fieldName) {
         return !REGEXP_META_PREFIX.test(fieldName);
     });
-}
-
-function capitalize(a, b, c) {
-    return b.toUpperCase() + c;
-}
+};
 
-/**
- * Separates camel case or white-space-, hypen-, or underscore-separated-words into truly separate words and capitalizing the first letter of each.
- * @param string
- * @returns {string}
- * @memberOf module:fields
- */
-function titleize(string) {
-    return (REGEXP_LOWER_CASE_LETTER.test(string) ? string : string.toLowerCase())
-        .replace(REGEXP_WORD_SEPARATORS, capitalize)
-        .replace(REGEXP_CAPITAL_LETTERS, ' $&')
-        .trim();
-}
+exports.titleize = require('synonomous').prototype.toTitle;
 
-function getSchema(data){
-    return getFieldNames(data && data[0] || {}).map(function(name) {
-        return { name: name, header: titleize(name) };
+exports.getSchema = function(data){
+    return exports.getFieldNames(data && data[0] || {}).map(function(name) {
+        return { name: name, header: exports.titleize(name) };
     });
-}
-
-module.exports = {
-    getFieldNames: getFieldNames,
-    titleize: titleize,
-    getSchema: getSchema
 };
diff --git a/src/lib/misc.js b/src/lib/misc.js
new file mode 100644
index 000000000..0dfaab875
--- /dev/null
+++ b/src/lib/misc.js
@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * For each key in src:
+ * * When `src[key]` is defined, assigns it to `object[key]` when the latter does not exist or is writable or is a setter
+ * * When `src[key]` is undefined:
+ *    * When `object[key]` is a configurable property and not a setter, deletes it
+ *    * Else when `object[key]` is writable or is a setter, assigns `undefined` (setter handles deletion)
+ * @param {object} dest
+ * @param {object} src - Defined values set the corresponding key in `dest`. `undefined` values delete the key from `dest`.
+ */
+exports.assignOrDelete = function(dest, src) {
+    Object.keys(src).forEach(function(key) {
+        var descriptor = Object.getOwnPropertyDescriptor(dest, key),
+            value = src[key];
+
+        if (value !== undefined) {
+            if (!descriptor || descriptor.writable || descriptor.set) {
+                dest[key] = value;
+            }
+        } else if (descriptor) {
+            if (descriptor.configurable && !descriptor.set) {
+                delete dest[key];
+            } else if (descriptor.writable || descriptor.set) {
+                dest[key] = undefined;
+            }
+        } // else no descriptor so no property to delete
+    });
+};
