//==============================================================================
//
//   Purpose:    Builds a table, client-side.
//
//               The public surface is a set of data types (MWClientTable,
//               MWColumn, MWCustomCellSpec, MWCellLinkDetail) instantiated by
//               callers. All of the actual behavior - rendering, sorting,
//               filtering and DOM linking - lives in the MWTable module
//               defined at the bottom of this file. The data types delegate to
//               it. This keeps the behavior in a single, testable module while
//               leaving the public constructor API (used across the codebase)
//               unchanged.
//
//==============================================================================
/*global
    htmlEncode
*/

//  MWTable is the module defined near the bottom of this file. The public data
//  types above delegate down to it, so their references to MWTable are
//  legitimately before its definition.
/* eslint-disable no-use-before-define */


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
function MWCellLinkDetail(options_) {
    var self = this;
    self.simpleLink = options_.simpleLink;
    self.doubleQuoteReadyJS = options_.doubleQuoteReadyJS;
    self.openInOtherWindow = !!options_.openInOtherWindow;
    self.dialogLink = !!options_.dialogLink;
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// eslint-disable-next-line no-unused-vars
function mwBuildSimpleLink(url_, openInOtherWindow_) {
    return new MWCellLinkDetail({
        simpleLink: url_,
        openInOtherWindow: openInOtherWindow_
    });
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// eslint-disable-next-line no-unused-vars
function mwBuildLinkScript(doubleQuoteReadyJS_, openInOtherWindow_) {
    return new MWCellLinkDetail({
        doubleQuoteReadyJS: doubleQuoteReadyJS_,
        openInOtherWindow: openInOtherWindow_
    });
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// eslint-disable-next-line no-unused-vars
function MWCustomCellSpec(options_) {
    if (null === options_ || typeof options_ === 'string') {
        options_ = { rawValue: options_ || '' };
    } else {
        options_ = options_ || {};
    }

    var self = this,
        colSpan = options_.colSpan || 1,
        rowSpan = options_.rowSpan || 1,
        strValueHTML = options_.valueHTML || htmlEncode(options_.rawValue || ''),
        cellId = (options_.cellId || '') + '';

    self.getColSpan =
        function () {
            return colSpan;
        };

    self.getRowSpan =
        function () {
            return rowSpan;
        };

    self.getValueHTML =
        function () {
            return strValueHTML;
        };

    self.getCellId =
        function () {
            return cellId;
        };
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
var g_nextGeneratedColLinkIdNum = 1;
function MWColumn(options_) {
    options_ = options_ || {};

    var self = this,
        sortInfo = options_.sortInfo;

    self.columnName = options_.columnName;

    self.simpleDisplayColumnPropertyName =
        options_.simpleDisplayColumnPropertyName; // Name of the property to grab from the array being rendered.

    self.simpleDisplayColumnNeedsMultilineEncoding =
        options_.simpleDisplayColumnNeedsMultilineEncoding; // If set for a simple display column, it will be htmlMultilineEncoded.

    self.simpleDisplayColumnIsAlreadyEncoded =
        options_.simpleDisplayColumnIsAlreadyEncoded; // If not set for a simple display column, it will be htmlEncoded.


    self.colLinkId = 'mwColLinkId.' + g_nextGeneratedColLinkIdNum++;


    // Function provided for custom rendering. Takes the following form:
    //
    //      fnCustomRenderCellContents(
    //          objRow_,
    //          objColumn_,
    //          array_,
    //          rowIndex_)
    self.fnCustomRenderCellContents =
        options_.fnCustomRenderCellContents;

    self.customRenderCellParams =
        options_.customRenderCellParams;

    self.additionalCellClasses = options_.additionalCellClasses || '';

    self.additionalHeaderClasses = options_.additionalHeaderClasses || '';


    // If the sortInfo property includes a fnCustomSort property, and the
    // MWClientTable object has been linked to dom elements, the function will
    // be invoked as follows:
    //
    //      sortInfo.fnCustomSort(
    //                  objMWColumn_,       // The MWColumn object
    //                  ascending_,         // Indicates whether the
    //                                      // sort should be ascending
    //                  columnHeaderCell_)  // Column header DOM element
    //
    // Otherwise, sorting relies on a data attribute associated with the row,
    // and a specific property on that object. By default, the attribute used
    // has the name 'data-rowData' and the property used will have the same
    // name as that given by the "simpleDisplayColumnPropertyName" option.
    //
    // If these defaults are appropriate for the sort, it's only necessary to
    // assign an empty object as the "sortInfo" property:
    //
    //      {
    //          ...
    //          sortInfo: {},
    //          ...
    //      }
    //
    // These defaults can be overridden by setting the "rowDataAttrName"
    // and "rowDataAttrPropertyName" properties on the sortInfo.
    //
    if (sortInfo) {
        self.sortInfo = sortInfo;
        sortInfo.rowDataAttrName =
            sortInfo.rowDataAttrName || 'data-rowData';
        sortInfo.rowDataAttrPropertyName =
            sortInfo.rowDataAttrPropertyName || options_.simpleDisplayColumnPropertyName;
    }



    self.fnAdditionalCellClasses = options_.fnAdditionalCellClasses;
    //
    // When set, called to retrieve classes to add to the cell. Usage:
    //
    //      fnAdditionalCellClasses(
    //          objRow_,
    //          objColumn_,
    //          array_,
    //          idxRow_)
    //
    //      returns:
    //              "classes to add to the cell"
    //

    self.fnBuildCellLinkDetail = options_.fnBuildCellLinkDetail;
    //
    // When set, used to build a link/click handler for the cells
    // of this column. Usage:
    //
    //      fnBuildCellLinkDetail(
    //          objRow_,
    //          objColumn_,
    //          array_,
    //          rowIndex_)
    //
    //      returns:
    //              An instance of MWCellLinkDetail
    //              (or nothing if no linking/scripting for the given cell)
    //


    //  Sub-columns are used to support grouping headers.
    self.arrSubColumns = options_.arrSubColumns || [];
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
function MWClientTable(options_) {
    options_ = options_ || {};

    var self = this;
    self.noDataMessage = options_.noDataMessage || 'No Data';
    self.arrColumns = options_.arrColumns || [];
    self.tableId = options_.tableId || '';
    self.tableScrollName = options_.tableScrollName || '';
    self.additionalTableClasses = options_.additionalTableClasses || '';
    self.suppressReportTableClass = options_.suppressReportTableClass;
    self.suppressTableHeader = options_.suppressTableHeader;
    self.fnAdditionalRowClasses = options_.fnAdditionalRowClasses;
    self.cssClassPrefix = options_.cssClassPrefix;
    self.tableHeaderClass = options_.tableHeaderClass;
    self.suppressTableHeaderRowClass = options_.suppressTableHeaderRowClass;
    self.showTableIfNoData = options_.showTableIfNoData || false;
    self.dataSource = options_.dataSource;
    self.paging = options_.paging;
    //
    // paging (server-side): { pageSize: N, mode: 'append', chunkSeparator: bool }
    // (chunkSeparator optional). When set alongside dataSource, the table fetches
    // one page at a time. fnBuildPayload receives the request state (see below).
    // Append consumers should supply fnExtractTotalCount so the row count is a
    // stable server-side total; absent it, the count falls back to the rows
    // returned in the response.
    //
    //   - mode: 'append' ("load more"): loadInto()/showFirstPage() renders the
    //     first page plus a "(Rows 1 to X of N)" + Load more control; loadMore()
    //     fetches the next page and appends its rows to the ones already shown
    //     (nothing is discarded), so earlier pages' DOM - including any
    //     checkbox/field state - stays live. Use this for a large result set the
    //     user selects across.
    //
    // When set, the table can fetch its own rows from the server via
    // loadInto()/reload() instead of having them serialized into the page.
    //
    //  Every dataSource callback receives a single params_ object. All of them
    //  carry the live "table" and the "dataSource" config; each also carries its
    //  own data (json / error / command+payload+etc.).
    //
    //      dataSource: {
    //          command:        'Module_FunctionName', // remote-scripting command
    //          fnBuildPayload: function (params_) {...},  // { table, dataSource }
    //                                                  // -> request payload, re-run each load
    //          fnExtractArray: function (params_) {...},  // { table, dataSource, json }
    //                                                  // -> row array
    //          doingWhat:      'Loading...',           // optional status text
    //          loadingHtml:    '<div>...</div>',       // optional placeholder
    //          errorMessage:   'Could not load.',      // optional; shown in a
    //                                                  // full-width row if the load fails
    //          fnBuildErrorMessage: function (params_) {...}, // optional;
    //                                                  // { table, dataSource, error }
    //                                                  // -> error-row text
    //          fnTransport:    function (params_) {...} // optional; params_ is
    //                                                  // { table, dataSource, command,
    //                                                  // payload, doingWhat, fnOnSuccess,
    //                                                  // fnOnError }. Defaults to the
    //                                                  // jsrsExecuteWithErrorP adapter.
    //                                                  // Call params_.fnOnSuccess(json_)
    //                                                  // to succeed or
    //                                                  // params_.fnOnError(error_) to fail.
    //                                                  // Call fnOnError_(error_) to fail.
    //          fnOnRowsRendered: function (targetElement_) {...} // optional; called
    //                                                  // after every render AND every
    //                                                  // append, to (re-)wire per-row
    //                                                  // behavior not baked into the
    //                                                  // markup (e.g. handlers on rows
    //                                                  // added by a later loadMore()).
    //          fnGetRowKey:    function (row_) {...}    // optional; append paging
    //                                                  // only. Returns a stable
    //                                                  // unique key for a row. When
    //                                                  // set, a row whose key was
    //                                                  // already rendered is dropped
    //                                                  // from a later appended page
    //                                                  // instead of shown twice (the
    //                                                  // result set can shift between
    //                                                  // fetches). Omit to keep every
    //                                                  // fetched row.
    //      }
    //
    //
    // When set, called to retrieve classes to add to the row. Usage:
    //
    //      fnAdditionalRowClasses(
    //          objRow_,
    //          array_,
    //          idxRow_,
    //          cssClassPrefix_)
    //
    //      returns:
    //              "classes to add to the row"
    //


    self.fnOverrideGetRowClass = options_.fnOverrideGetRowClass;
    //
    // When set, called to retrieve the primary class to use for the row. Usage:
    //
    //      fnOverrideGetRowClass(
    //          objRow_,
    //          array_,
    //          idxRow_,
    //          cssClassPrefix_)
    //
    //      returns:
    //              "primary class(es) to use for the row"
    //
    // When not set, "oddRow" and "evenRow" will be used
    // (with the table's "cssClassPrefix" prepended, if appropriate).
    //


    self.fnGetCheckDetailsForRow =
        options_.fnGetCheckDetailsForRow;
    //
    // When set, called to retrieve details about how to handle a given row's checkbox. Usage:
    //
    //      fnGetCheckDetailsForRow(
    //          objRow_,
    //          array_,
    //          idxRow_)
    //
    //      returns:
    //              {
    //                  value: "string-value-to-assign-cb",
    //                  checked: true if the cb should be checked.
    //              }
    //

    self.flagCBsToFireOnChange =
        options_.flagCBsToFireOnChange;
    // When set, if the table includes a checkbox column, those checkboxes will
    // be configured to have the "fireOnChange_" parameter set when either of
    // "checkAllRows()" or "checkSingleRow()" is called.


    self.fnAdditionalRowAttrs =
        options_.fnAdditionalRowAttrs;
    //
    // When set, called to retrieve a string of additional attribute definitions.
    //
    //      fnAdditionalRowAttrs(
    //          objRow_,
    //          array_,
    //          idxRow_)
    //
    //      returns: "data-attr1='' data-attr2='' ..."
    //
}

//==============================================================================
//  MWColumn - thin delegators to MWTable.
//==============================================================================

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWColumn.prototype.addSubColumn =
    function (objColumn_) {
        this.arrSubColumns.push(objColumn_);

        return objColumn_;
    };

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWColumn.prototype.getFlattenedColumnCount =
    function () {
        return MWTable.getFlattenedColumnCount(this);
    };

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWColumn.prototype.flattenToEndOfArrayOfLeafColumns =
    function (optionalLeafColumnArray_) {
        return MWTable.flattenColumnToLeaves(this, optionalLeafColumnArray_);
    };

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWColumn.prototype.getColumnName =
    function () {
        return this.columnName;
    };

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWColumn.prototype.getCustomRenderCellParams =
    function () {
        return this.customRenderCellParams;
    };

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWColumn.prototype.buildCellContents =
    function (array_, rowIndex_) {
        return MWTable.buildCellContents(this, array_, rowIndex_);
    };


//==============================================================================
//  MWClientTable - thin delegators to MWTable.
//==============================================================================

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.getTableId = function() {
    return this.tableId;
};


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.flattenToEndOfArrayOfLeafColumns =
    function () {
        return MWTable.flattenColumnsToLeaves(this.arrColumns);
    };


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.addColumn =
    function (objColumn_) {
        this.arrColumns.push(objColumn_);
        return objColumn_;
    };


//------------------------------------------------------------------------------
//
// Removes the column. If found and removed, the column is returned.
// If the column is included multiple times, it will be removed in each case.
//
//------------------------------------------------------------------------------
MWClientTable.prototype.removeColumn =
    function (objColumn_) {
        var arrColumns = this.arrColumns,
            i,
            rc;
        for (i = 0; i < arrColumns.length; ++i) {
            if (objColumn_ === arrColumns[i]) {
                arrColumns.splice(
                    i, // start
                    1); // deleteCount
                rc = objColumn_;
            }
        }
        return rc;
    };


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.buildArrayOfHeaderRowColumnObjects =
    function () {
        return MWTable.buildArrayOfHeaderRowColumnObjects(this);
    };


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.getCheckboxFunction =
    function () {
        return this.fnGetCheckDetailsForRow;
    };
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.setCheckboxFunction =
    function (fnGetCheckDetailsForRow_) {
        this.fnGetCheckDetailsForRow = fnGetCheckDetailsForRow_;
    };


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.buildTableForArray =
    function (array_) {
        return MWTable.buildTableForArray(this, array_);
    };


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
MWClientTable.prototype.linkTableObjectsToElement =
    function (objTableAncestorElement_) {
        return MWTable.linkTableObjectsToElement(this, objTableAncestorElement_);
    };


//------------------------------------------------------------------------------
// Fetches rows from the server (per the table's dataSource) and renders them
// into objTargetElement_, remembering it for later reload() calls.
//------------------------------------------------------------------------------
MWClientTable.prototype.loadInto =
    function (objTargetElement_) {
        return MWTable.loadTableData(this, objTargetElement_);
    };


//------------------------------------------------------------------------------
// Re-fetches into the element last passed to loadInto(). Throws if loadInto()
// has not been called.
//------------------------------------------------------------------------------
MWClientTable.prototype.reload =
    function () {
        return MWTable.reloadTableData(this);
    };


//------------------------------------------------------------------------------
// Append-paging navigation: loads the next page and appends its rows to those
// already shown. A no-op once every row is loaded.
//------------------------------------------------------------------------------
MWClientTable.prototype.loadMore =
    function () {
        return MWTable.loadMore(this);
    };


//------------------------------------------------------------------------------
// Seeds an append-paged table with a first page the caller already fetched
// (rendering it into objTargetElement_ and wiring up loadMore()), instead of
// having the table fetch page 0. tmpTotalCount_ is the full server-side match
// count.
//------------------------------------------------------------------------------
MWClientTable.prototype.showFirstPage =
    function (objTargetElement_, array_, tmpTotalCount_) {
        return MWTable.showFirstPage(this, objTargetElement_, array_, tmpTotalCount_);
    };


//==============================================================================
//  Global call-through shims.
//
//  Kept global for the many existing call sites. (Sorting is now handled by the
//  delegated click listener inside MWTable, so no mwSortClientColumn global is
//  needed.)
//==============================================================================

//------------------------------------------------------------------------------
// Filters rows to show if any cell in the row matches the filter text
//------------------------------------------------------------------------------
// eslint-disable-next-line no-unused-vars
function mwFilterTableRowsToFilterText(table_, filterText_) {
    return MWTable.filterTableRowsToFilterText(table_, filterText_);
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// eslint-disable-next-line no-unused-vars
function mwRemoveTableRows(table_, fnShouldRemoveRow_) {
    return MWTable.removeTableRows(table_, fnShouldRemoveRow_);
}


//==============================================================================
//
//   Purpose:    Client-side table module.
//
//==============================================================================
/*global
    cdBuildFontIconElem
    checkAttribute
    FontIconId_Enum
    g_dcForcedIgnoreClass
    getEventElement
    getRawFontId
    HtmlUtilities
    htmlMultilineEncode
    jsrsExecuteWithErrorP
    mjtElemData
    rsCallbackHandleStandardJSONResponse
    trim
*/

//==============================================================================
//  MWTable - owns all behavior for the public data types (rendering, sorting,
//  filtering and DOM linking). The data types (MWClientTable, MWColumn, etc.)
//  delegate to it.
//==============================================================================
var MWTable = (function () {

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvIsCustomCellSpecObject(object_) {
        if(object_ &&
            typeof object_ === 'object' &&
            object_.constructor &&
            object_.constructor.name === 'MWCustomCellSpec') {
            return true;
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbGetFlattenedColumnCount(objColumn_) {
        var arrSubColumns = objColumn_.arrSubColumns,
            idxSubColumn,
            rc = 0;

        if(arrSubColumns.length) {
            for(idxSubColumn = 0; idxSubColumn < arrSubColumns.length; ++idxSubColumn) {
                rc += pbGetFlattenedColumnCount(arrSubColumns[idxSubColumn]);
            }
        } else {
            rc = 1;
        }

        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbFlattenColumnToLeaves(objColumn_, optionalLeafColumnArray_) {
        optionalLeafColumnArray_ = optionalLeafColumnArray_ || [];

        var arrSubColumns = objColumn_.arrSubColumns;

        if(arrSubColumns.length) {
            for(var idxSubColumn = 0; idxSubColumn < arrSubColumns.length; ++idxSubColumn) {
                pbFlattenColumnToLeaves(arrSubColumns[idxSubColumn], optionalLeafColumnArray_);
            }
        } else {
            optionalLeafColumnArray_.push(objColumn_);
        }

        return optionalLeafColumnArray_;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbFlattenColumnsToLeaves(arrColumnObjects_, optionalLeafColumnArray_) {
        optionalLeafColumnArray_ = optionalLeafColumnArray_ || [];

        if(arrColumnObjects_.length) {
            for(var idxColumn = 0; idxColumn < arrColumnObjects_.length; ++idxColumn) {
                pbFlattenColumnToLeaves(arrColumnObjects_[idxColumn], optionalLeafColumnArray_);
            }
        }

        return optionalLeafColumnArray_;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    // rowIndex_ is the position within array_ (used to look the row up).
    // logicalRowIndex_ is the row's index within the overall result set; it
    // differs from rowIndex_ only for an appended page (see pbBuildTableForArray's
    // indexOffset), and is what the custom renderer sees so per-row ids/field
    // names stay globally unique. Defaults to rowIndex_ when not supplied.
    function pbBuildCellContents(objColumn_, array_, rowIndex_, logicalRowIndex_) {
        var objRow = array_[rowIndex_],
            tmpLogicalRowIndex =
                logicalRowIndex_ === undefined ? rowIndex_ : logicalRowIndex_,
            fnCustomRenderCellContents = objColumn_.fnCustomRenderCellContents,
            rc;

        if(fnCustomRenderCellContents) {
            rc = fnCustomRenderCellContents(
                objRow,
                objColumn_,
                array_,
                tmpLogicalRowIndex);
        } else {
            //  Simple column...
            var simpleDisplayColumnPropertyName = objColumn_.simpleDisplayColumnPropertyName,
                simpleDisplayColumnNeedsMultilineEncoding = objColumn_.simpleDisplayColumnNeedsMultilineEncoding,
                simpleDisplayColumnIsAlreadyEncoded = objColumn_.simpleDisplayColumnIsAlreadyEncoded,
                objPropertyValue = objRow ? objRow[simpleDisplayColumnPropertyName] : undefined;

            if(objPropertyValue !== undefined && objPropertyValue !== null) {
                rc = objPropertyValue.toString();
                if(simpleDisplayColumnNeedsMultilineEncoding) {
                    rc = htmlMultilineEncode(rc);
                } else if(true === simpleDisplayColumnIsAlreadyEncoded) {
                    // no-op - already encoded
                } else {
                    rc = htmlEncode(rc);
                }
            } else {
                rc = '';
            }
        }

        return rc;
    }


    //--------------------------------------------------------------------------
    //
    // Given a column object, this recursive function will build out an array
    // in which each successive element of the array corresponds to an array of
    // column objects that together define a single row of the overall,
    // potentially multi-rowed header.
    //
    //--------------------------------------------------------------------------
    function pvExtendArrayOfHeaderRowColumnObjects(objColumn_, arrHeaderRowColumnObjects_, zeroBasedDepthIndex_) {
        if(zeroBasedDepthIndex_ > arrHeaderRowColumnObjects_.length - 1) {
            //  We haven't yet added the row we're about to be dealing with, so add it now...
            arrHeaderRowColumnObjects_.push([]);
        }
        var idxSubColumn,
            arrSubColumns = objColumn_.arrSubColumns,
            arrCurrLevelColumns = arrHeaderRowColumnObjects_[zeroBasedDepthIndex_];

        //  Add this column
        arrCurrLevelColumns.push(objColumn_);

        // Add any subcolumns
        for(idxSubColumn = 0; idxSubColumn < arrSubColumns.length; ++idxSubColumn) {
            pvExtendArrayOfHeaderRowColumnObjects(
                arrSubColumns[idxSubColumn], // objColumn_
                arrHeaderRowColumnObjects_,
                zeroBasedDepthIndex_ + 1); // 1 row deeper...
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbBuildArrayOfHeaderRowColumnObjects(objTable_) {
        var rc = [],
            idxColumn,
            arrColumns = objTable_.arrColumns;

        for(idxColumn = 0; idxColumn < arrColumns.length; ++idxColumn) {
            pvExtendArrayOfHeaderRowColumnObjects(
                arrColumns[idxColumn], // objColumn_
                rc, // arrHeaderRowColumnObjects_
                0); // zeroBasedDepthIndex_
        }

        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvGetTableCssClass(descendentElem_) {
        var objParentTable = checkAttribute(descendentElem_, 'data-mwClientTable'),
            strCssClassPrefix =
                (objParentTable ?
                    objParentTable.getAttribute('data-cssClassPrefix') :
                    '') || '';
        return strCssClassPrefix;
    }


    //--------------------------------------------------------------------------
    // This signature must match fnOverrideGetRowClass, hence the unused parameters.
    //--------------------------------------------------------------------------
    function pvStandardGetClientTableRowClass(objRow_, array_, idxRow_, cssClassPrefix_) {
        // As a sanity check, ensure that "cssClassPrefix_" is actually a string.
        cssClassPrefix_ = (
            typeof cssClassPrefix_ !== 'string' ?
                '' :
                cssClassPrefix_) || '';

        return cssClassPrefix_ + (idxRow_ % 2 ? 'evenRow' : 'oddRow');
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvApplyOddOrEvenClassToRow(objRow_, idxRow_, cssClassPrefix_) {
        if(objRow_.classList) {
            // As a sanity check, ensure that "cssClassPrefix_" is actually a string.
            cssClassPrefix_ =
                (typeof cssClassPrefix_ !== 'string' ?
                    '' :
                    cssClassPrefix_) || '';

            // First, get rid of any exiting odd/even classes
            objRow_.classList.remove(cssClassPrefix_ + 'evenRow');
            objRow_.classList.remove(cssClassPrefix_ + 'oddRow');

            // Now add the correct one back
            objRow_.classList.add(
                pvStandardGetClientTableRowClass(
                    null,
                    null,
                    idxRow_,
                    cssClassPrefix_));
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvBuildSortAddendum(sortDir_) {
        var rc = '';
        if(sortDir_) {
            rc = cdBuildFontIconElem({
                fontId:
                    sortDir_ === 1 ?
                        FontIconId_Enum.fiiArrowSortUp :
                        FontIconId_Enum.fiiArrowSortDown,
                terseFontIcon: 1,
                additionalFontIconClasses: 'mwSortIcon paddingLeftXSmall'
            });
        }
        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbSortClientColumn(columnHeaderCell_, sortInfo_, cssClassPrefix_) {
        var strRowDataAttrName = sortInfo_.rowDataAttrName,
            strRowDataAttrPropertyName = sortInfo_.rowDataAttrPropertyName,
            strRowDataValue,
            objRowData,
            idxVisible,
            objAncestor = columnHeaderCell_,
            strSortDir = columnHeaderCell_.getAttribute('data-mwSortDir'),
            tmpSortDir =
                strSortDir === '1' ?
                    1 :
                    strSortDir === '-1' ?
                        -1 :
                        0,
            tmpNewSortDir = tmpSortDir === 1 ? -1 : 1,
            strSortAddendum = pvBuildSortAddendum(tmpNewSortDir),
            objTable,
            trs,
            tr,
            idxRow,
            arrRowInfos = [],
            objColumn = mjtElemData(columnHeaderCell_, 'data-mwColLinkObj'),
            objSortInfo =
                objColumn ?
                    objColumn.sortInfo || sortInfo_ :
                    sortInfo_,
            fnCustomSort = objSortInfo ? objSortInfo.fnCustomSort : 0;

        while(objAncestor && !objTable) {
            if(objAncestor.nodeName === 'TABLE') {
                objTable = objAncestor;
            } else {
                objAncestor = objAncestor.parentNode;
            }
        }

        if(fnCustomSort) {
            fnCustomSort(
                objColumn,
                tmpNewSortDir === 1, // ascending_
                columnHeaderCell_);
        } else {
            //  Clear away the sort icon...
            objTable.querySelectorAll('.mwSortIcon').forEach(
                function (object_) {
                    object_.parentNode.removeChild(object_);
                });

            // ...and "sortSelected" indicator...
            objTable.querySelectorAll('.sortSelected').forEach(
                function (object_) {
                    object_.className =
                        object_.className.replace('sortSelected', '');
                });

            columnHeaderCell_.parentNode.querySelectorAll('[data-mwSortDir]').forEach(
                function (object_) {
                    object_.setAttribute('data-mwSortDir', 0);
                });

            columnHeaderCell_.setAttribute('data-mwSortDir', tmpNewSortDir);
            columnHeaderCell_.innerHTML = columnHeaderCell_.innerHTML + strSortAddendum;
            columnHeaderCell_.className = trim(columnHeaderCell_.className) + ' sortSelected';

            trs = objTable.rows;
            for(idxRow = trs.length - 1; idxRow >= 0; --idxRow) {
                tr = trs[idxRow];
                strRowDataValue = tr.getAttribute(strRowDataAttrName);
                if(strRowDataValue) {
                    objRowData = JSON.parse(unescape(strRowDataValue));
                    arrRowInfos.push({
                        rowData: objRowData,
                        idxRow: idxRow,
                        tr: tr,
                        parentNode: tr.parentNode
                    });
                    tr.parentNode.removeChild(tr);
                }
            }

            arrRowInfos.sort(
                function (o1_, o2_) {
                    var rd1 = o1_.rowData,
                        p1 = rd1[strRowDataAttrPropertyName],
                        rd2 = o2_.rowData,
                        p2 = rd2[strRowDataAttrPropertyName],
                        rc;

                    if(p1 === p2) {
                        // Since the values compare equally, maintain the original
                        // sort order by now comparing the original row indices.
                        if(o1_.idxRow < o2_.idxRow) {
                            rc = -1;
                        } else if(o1_.idxRow > o2_.idxRow) {
                            rc = 1;
                        } else {
                            rc = 0;
                        }

                        //  Need to multiply by the new sort order (1/-1) so that if
                        // we're sorting descending, the sort order maintenance will
                        // hold.
                        rc = tmpNewSortDir * rc;
                    } else if(p1 === null || p1 === undefined) {
                        rc = -1;
                    } else if(p2 === null || p2 === undefined) {
                        rc = 1;
                    } else {
                        if(sortInfo_.isNumber) {
                            var f1 = parseFloat(p1),
                                f2 = parseFloat(p2);
                            rc =
                                f1 === f2 ?
                                    0 :
                                    f1 < f2 ?
                                        -1 :
                                        1;
                        } else {
                            rc = p1.toString().toLowerCase().localeCompare(p2.toString().toLowerCase());
                        }

                        if(rc === 0) {
                            //  The values compare equal (e.g. they differ only by
                            // case, or are numerically equal), so maintain the
                            // original sort order by comparing the original row
                            // indices - the engine's sort is not stable. Multiply
                            // by the new sort order (1/-1) so the descending
                            // negation below cancels out and equal rows keep their
                            // original order in both directions.
                            rc = tmpNewSortDir * (o1_.idxRow - o2_.idxRow);
                        }
                    }

                    return tmpNewSortDir === 1 ? rc : -rc;
                });


            idxVisible = 0;
            arrRowInfos.forEach(function (objRowInfo_) {
                objRowInfo_.parentNode.appendChild(objRowInfo_.tr);
                if(objRowInfo_.tr.style.display !== 'none') {
                    pvApplyOddOrEvenClassToRow(objRowInfo_.tr, idxVisible, cssClassPrefix_);
                    ++idxVisible;
                }
            });
        }
    }


    //--------------------------------------------------------------------------
    // Builds the header rows of the view-model: one array of header cells per
    // header level (grouped headers produce more than one). Each cell carries
    // only its rendered content for now; spans/classes are added as the
    // serializer needs them.
    //--------------------------------------------------------------------------
    function pvBuildHeaderRowsViewModel(objTable_, arrHeaderRowColumnObjects_) {
        var tmpHeaderRowCount = arrHeaderRowColumnObjects_.length,
            strCssClassPrefix = objTable_.cssClassPrefix || '',
            tmpSuppressHeaderRowClass = objTable_.suppressTableHeaderRowClass,
            arrRC = [],
            idxHeaderRow,
            arrColumnsOfRow,
            arrCells,
            idxCol,
            objColumn,
            objSortInfo,
            tmpInitialSortDir,
            tmpFlattenedColumnCount,
            tmpIsLastHeaderRow,
            strHeaderClass,
            strAdditionalHeaderClasses;
        for(idxHeaderRow = 0; idxHeaderRow < tmpHeaderRowCount; ++idxHeaderRow) {
            arrColumnsOfRow = arrHeaderRowColumnObjects_[idxHeaderRow];
            tmpIsLastHeaderRow = idxHeaderRow + 1 >= tmpHeaderRowCount;
            arrCells = [];
            for(idxCol = 0; idxCol < arrColumnsOfRow.length; ++idxCol) {
                objColumn = arrColumnsOfRow[idxCol];
                objSortInfo = objColumn.sortInfo;
                tmpInitialSortDir = objSortInfo ? objSortInfo.initialSortDir : 0;
                tmpFlattenedColumnCount = pbGetFlattenedColumnCount(objColumn);
                // Suppressing the header-row class zeroes the base class but
                // still keeps any per-column additional header classes.
                strHeaderClass =
                    tmpSuppressHeaderRowClass ?
                        '' :
                        strCssClassPrefix +
                            (objSortInfo ? 'headerSortableCol' : 'headerCol');
                strAdditionalHeaderClasses =
                    objColumn.additionalHeaderClasses ?
                        ' ' + objColumn.additionalHeaderClasses :
                        '';
                arrCells.push({
                    contentHtml:
                        objColumn.getColumnName() +
                        pvBuildSortAddendum(tmpInitialSortDir),
                    // A parent header spans its leaf columns; a standalone leaf
                    // on a non-final header row instead spans down to the last
                    // header row.
                    colSpan: tmpFlattenedColumnCount,
                    rowSpan:
                        tmpFlattenedColumnCount === 1 && !tmpIsLastHeaderRow ?
                            tmpHeaderRowCount - idxHeaderRow :
                            1,
                    classes: strHeaderClass + strAdditionalHeaderClasses,
                    colLinkId: objColumn.colLinkId,
                    sortInfo: objSortInfo,
                    sortDir: tmpInitialSortDir
                });
            }
            arrRC.push(arrCells);
        }
        return arrRC;
    }


    //--------------------------------------------------------------------------
    // Describes a row's leading checkbox cell, or undefined when the table has
    // no checkbox column at all. Returns null when the column exists but this
    // row supplies no details (an empty cell). The id deliberately mirrors the
    // string builder's format (tableScrollName + 'ChkRow' + tableId + index) so
    // per-row ids stay stable, including for appended pages via the logical
    // index.
    //--------------------------------------------------------------------------
    function pvBuildRowCheckboxViewModel(
            objTable_, objRow_, array_, tmpLogicalRowIndex_) {
        var fnGetCheckDetailsForRow = objTable_.fnGetCheckDetailsForRow,
            objCheckDetails;
        if(!fnGetCheckDetailsForRow) {
            return undefined;
        }
        objCheckDetails =
            fnGetCheckDetailsForRow(objRow_, array_, tmpLogicalRowIndex_);
        if(!objCheckDetails) {
            return null;
        }
        return {
            name: 'chkRow' + objTable_.tableId,
            id:
                objTable_.tableScrollName + 'ChkRow' +
                objTable_.tableId + tmpLogicalRowIndex_,
            value: objCheckDetails.value,
            disabled: !!objCheckDetails.disabled,
            checked: !!objCheckDetails.checked,
            additionalAttributes: objCheckDetails.additionalAttributes || '',
            onClickJs:
                'checkSingleRow(event,this,\'' + objTable_.tableId + '\'' +
                (objTable_.flagCBsToFireOnChange ?
                    ',undefined,undefined,true' :
                    '') +
                ')'
        };
    }


    //--------------------------------------------------------------------------
    // Describes a single body cell: its rendered content plus any additional
    // classes (static additionalCellClasses combined with per-row
    // fnAdditionalCellClasses). Content reuses pbBuildCellContents so custom
    // renderers and simple-column encoding behave exactly as in the string
    // builder.
    //--------------------------------------------------------------------------
    function pvBuildBodyCellViewModel(
            objColumn_, array_, idxRow_, tmpLogicalRowIndex_) {
        var objRow = array_[idxRow_],
            strAdditionalCellClasses = objColumn_.additionalCellClasses || '',
            objCellLinkDetail,
            strSimpleLink,
            doubleQuoteReadyJS,
            tmpIsDialogLink,
            strOnClickJs = '',
            strLinkHref = '',
            objCellContents,
            tmpIsCustomCellSpecObject,
            strContentHtml,
            tmpColSpan,
            tmpRowSpan,
            strCellId;
        if(objColumn_.fnAdditionalCellClasses) {
            strAdditionalCellClasses =
                trim(
                    strAdditionalCellClasses + ' ' +
                    objColumn_.fnAdditionalCellClasses(
                        objRow, objColumn_, array_, tmpLogicalRowIndex_));
        }

        // A column may attach a link/click behaviour to each cell. When it
        // yields a simpleLink or a script, the cell becomes a linkedCell and
        // gets an onclick; a dialog link additionally wraps its content in an
        // <a href> (the serializer does that wrapping).
        if(objColumn_.fnBuildCellLinkDetail) {
            objCellLinkDetail =
                objColumn_.fnBuildCellLinkDetail(
                    objRow, objColumn_, array_, tmpLogicalRowIndex_);
        }
        if(objCellLinkDetail) {
            tmpIsDialogLink = objCellLinkDetail.dialogLink;
            strSimpleLink = objCellLinkDetail.simpleLink;
            doubleQuoteReadyJS = objCellLinkDetail.doubleQuoteReadyJS;
            if(strSimpleLink || doubleQuoteReadyJS) {
                strAdditionalCellClasses =
                    trim(strAdditionalCellClasses + ' linkedCell');
                if(strSimpleLink) {
                    if(objCellLinkDetail.openInOtherWindow) {
                        strOnClickJs =
                            'window.open(\'' + strSimpleLink + '\',\'_blank\');';
                    } else if(tmpIsDialogLink) {
                        strOnClickJs =
                            'clickedDialogLink(\'' + strSimpleLink + '\');';
                    } else {
                        strOnClickJs =
                            'window.location=\'' + strSimpleLink + '\';';
                    }
                } else {
                    strOnClickJs = doubleQuoteReadyJS;
                }
            }
            if(strSimpleLink && tmpIsDialogLink) {
                strLinkHref = strSimpleLink;
            }
        }

        // A cell's contents are either a plain HTML string or an
        // MWCustomCellSpec carrying its own span/id. Normalise to a string
        // plus the span/id fields the serializer needs.
        objCellContents =
            pbBuildCellContents(
                objColumn_, array_, idxRow_, tmpLogicalRowIndex_);
        tmpIsCustomCellSpecObject = pvIsCustomCellSpecObject(objCellContents);
        strContentHtml =
            tmpIsCustomCellSpecObject ?
                objCellContents.getValueHTML() :
                objCellContents;
        tmpColSpan =
            tmpIsCustomCellSpecObject ? objCellContents.getColSpan() : 1;
        tmpRowSpan =
            tmpIsCustomCellSpecObject ? objCellContents.getRowSpan() : 1;
        strCellId =
            tmpIsCustomCellSpecObject ? objCellContents.getCellId() : '';

        return {
            contentHtml: strContentHtml,
            classes: strAdditionalCellClasses,
            onClickJs: strOnClickJs,
            linkHref: strLinkHref,
            colSpan: tmpColSpan,
            rowSpan: tmpRowSpan,
            cellId: strCellId
        };
    }


    //--------------------------------------------------------------------------
    // Builds the body rows of the view-model: one row per array element, each
    // with an optional leading checkbox and a cell per leaf column carrying that
    // cell's rendered content. The logical row index (offset for appended pages)
    // is what per-row ids/field names key off of.
    //--------------------------------------------------------------------------
    function pvBuildBodyRowsViewModel(objTable_, array_, objBuildOptions_) {
        var arrLeafColumns = pbFlattenColumnsToLeaves(objTable_.arrColumns),
            tmpIndexOffset = objBuildOptions_.indexOffset || 0,
            strCssClassPrefix = objTable_.cssClassPrefix || '',
            fnGetRowClass =
                objTable_.fnOverrideGetRowClass ||
                pvStandardGetClientTableRowClass,
            fnAdditionalRowClasses = objTable_.fnAdditionalRowClasses,
            fnAdditionalRowAttrs = objTable_.fnAdditionalRowAttrs,
            arrRC = [],
            idxRow,
            objRow,
            arrCells,
            idxCol,
            objColumn,
            objCell,
            objCheckbox,
            strCheckboxId,
            tmpColSpan,
            tmpRowSpan,
            iSpan,
            tmpLogicalRowIndex,
            strFnAdditionalRowClasses,
            strAdditionalRowClasses,
            strAdditionalRowAttrs,
            // Tracks, per leaf column, how many further rows are still covered
            // by a rowspan started above - those positions emit no cell.
            arrRemainingRowSpans = [];
        if(!array_) {
            return arrRC;
        }
        for(idxCol = 0; idxCol < arrLeafColumns.length; ++idxCol) {
            arrRemainingRowSpans[idxCol] = 0;
        }
        for(idxRow = 0; idxRow < array_.length; ++idxRow) {
            objRow = array_[idxRow];
            tmpLogicalRowIndex = idxRow + tmpIndexOffset;

            strAdditionalRowClasses = '';
            if(fnAdditionalRowClasses) {
                strFnAdditionalRowClasses =
                    fnAdditionalRowClasses(objRow, array_, tmpLogicalRowIndex);
                if(strFnAdditionalRowClasses) {
                    strAdditionalRowClasses = ' ' + strFnAdditionalRowClasses;
                }
            }

            strAdditionalRowAttrs = '';
            if(fnAdditionalRowAttrs) {
                strAdditionalRowAttrs =
                    ' ' + fnAdditionalRowAttrs(objRow, array_, tmpLogicalRowIndex);
            }

            //  A row's leading checkbox (if any); its id also labels the
            //  first column's cell via a wrapping <label for>.
            objCheckbox =
                pvBuildRowCheckboxViewModel(
                    objTable_, objRow, array_, tmpLogicalRowIndex);
            strCheckboxId = objCheckbox && objCheckbox.id ? objCheckbox.id : '';

            arrCells = [];
            for(idxCol = 0; idxCol < arrLeafColumns.length; ++idxCol) {
                if(arrRemainingRowSpans[idxCol]) {
                    //  This position is covered by a rowspan from an earlier
                    //  row, so it emits no cell.
                    --arrRemainingRowSpans[idxCol];
                    continue;
                }
                objColumn = arrLeafColumns[idxCol];
                objCell =
                    pvBuildBodyCellViewModel(
                        objColumn, array_, idxRow, tmpLogicalRowIndex);
                //  Only the first leaf column's cell is wrapped in the
                //  checkbox's <label for>.
                objCell.labelFor = idxCol === 0 ? strCheckboxId : '';
                arrCells.push(objCell);
                tmpColSpan = objCell.colSpan;
                tmpRowSpan = objCell.rowSpan;
                if(tmpRowSpan) {
                    for(iSpan = 0; iSpan < tmpColSpan; ++iSpan) {
                        //  Mark the covered columns for the rows this cell
                        //  spans down into.
                        arrRemainingRowSpans[idxCol + iSpan] = tmpRowSpan - 1;
                    }
                }
                if(tmpColSpan > 1) {
                    //  Advance past the leaf columns this cell spans across.
                    idxCol += tmpColSpan - 1;
                }
            }
            arrRC.push({
                primaryClass:
                    fnGetRowClass(
                        objRow, array_, tmpLogicalRowIndex, strCssClassPrefix),
                additionalClasses: strAdditionalRowClasses,
                additionalAttrs: strAdditionalRowAttrs,
                checkbox: objCheckbox,
                cells: arrCells
            });
        }
        return arrRC;
    }


    //--------------------------------------------------------------------------
    // Describes the leading "check all" header cell, or null when the table has
    // no checkbox column. It spans down all header rows so it sits alongside a
    // grouped header, and its onclick toggles every row's checkbox.
    //--------------------------------------------------------------------------
    function pvBuildCheckAllHeaderCellViewModel(objTable_, tmpHeaderRowCount_) {
        if(!objTable_.fnGetCheckDetailsForRow) {
            return null;
        }
        return {
            classes: (objTable_.cssClassPrefix || '') + 'headerCol centerAlign',
            rowSpan: tmpHeaderRowCount_ > 1 ? tmpHeaderRowCount_ : 1,
            name: 'chkCheckAllRows' + objTable_.tableId,
            inputClass: g_dcForcedIgnoreClass,
            onClickJs:
                'checkAllRows(this,\'' + objTable_.tableId + '\'' +
                (objTable_.flagCBsToFireOnChange ?
                    ',undefined,undefined,true' :
                    '') +
                ')'
        };
    }


    //--------------------------------------------------------------------------
    // Pure, structural description of the table - header/body cells and their
    // content/spans - built with no HTML-string concatenation and no DOM. The
    // serializer (and, through it, pbBuildTableForArray) turns this into markup,
    // so this is the boundary that can be unit-tested by asserting on structure
    // rather than on an HTML blob.
    //--------------------------------------------------------------------------
    function pvBuildTableViewModel(objTable_, array_, objBuildOptions_) {
        objBuildOptions_ = objBuildOptions_ || {};
        var tmpRowCount = array_ ? array_.length : 0,
            arrHeaderRowColumnObjects =
                pbBuildArrayOfHeaderRowColumnObjects(objTable_),
            arrLeafColumns = pbFlattenColumnsToLeaves(objTable_.arrColumns),
            tmpShowTableIfNoData =
                objTable_.showTableIfNoData || objBuildOptions_.forceShowTable,
            // The full-width message shown when there are no data rows. Callers
            // (loading/error states) can override the text or supply raw markup.
            strMessage =
                typeof objBuildOptions_.fullWidthMessage !== 'undefined' ?
                    objBuildOptions_.fullWidthMessage :
                    objTable_.noDataMessage,
            strMessageContent =
                typeof objBuildOptions_.fullWidthMessageHtml !== 'undefined' ?
                    objBuildOptions_.fullWidthMessageHtml :
                    htmlEncode(strMessage),
            // The <table>'s class: 'reportTable' unless suppressed, plus any
            // caller-supplied additional classes.
            strReportTableClass =
                objTable_.suppressReportTableClass ? '' : 'reportTable',
            strTableClass =
                strReportTableClass +
                (objTable_.additionalTableClasses ?
                    ' ' + trim(objTable_.additionalTableClasses) :
                    '');
        return {
            tableClass: strTableClass,
            cssClassPrefix: objTable_.cssClassPrefix || '',
            tableId: objTable_.tableId || '',
            suppressHeader: !!objTable_.suppressTableHeader,
            headerRowClass: objTable_.tableHeaderClass || 'headerRow',
            // A <table> shell is emitted only when there's data to show (with
            // columns) or the caller forces an empty shell; otherwise the
            // serializer emits just the full-width message.
            render:
                !!((tmpRowCount && arrHeaderRowColumnObjects.length) ||
                    tmpShowTableIfNoData),
            hasCheckboxColumn: !!objTable_.fnGetCheckDetailsForRow,
            checkAllHeaderCell:
                pvBuildCheckAllHeaderCellViewModel(
                    objTable_, arrHeaderRowColumnObjects.length),
            headerRows:
                pvBuildHeaderRowsViewModel(objTable_, arrHeaderRowColumnObjects),
            bodyRows: pvBuildBodyRowsViewModel(objTable_, array_, objBuildOptions_),
            fullWidthMessage: {
                contentHtml: strMessageContent,
                colSpan: arrLeafColumns.length,
                cssClass: objBuildOptions_.fullWidthMessageClass || ''
            }
        };
    }


    //--------------------------------------------------------------------------
    // Serializes one header row's cells (the check-all cell is emitted
    // separately by the caller on the first row).
    //--------------------------------------------------------------------------
    function pvSerializeHeaderCells(arrHeaderCells_) {
        var rc = '',
            idxCell,
            objCell;
        for(idxCell = 0; idxCell < arrHeaderCells_.length; ++idxCell) {
            objCell = arrHeaderCells_[idxCell];
            rc +=
                '<td ' +
                (objCell.colSpan > 1 ?
                    'colspan="' + objCell.colSpan + '" ' :
                    (objCell.rowSpan > 1 ?
                        'rowspan="' + objCell.rowSpan + '" ' :
                        '')) +
                (objCell.sortDir ?
                    'data-mwSortDir="' + objCell.sortDir + '" ' :
                    '') +
                (objCell.sortInfo ?
                    "data-mwSortInfo='" +
                        escape(JSON.stringify(objCell.sortInfo)) + "' " :
                    '') +
                'data-mwColLinkId="' + objCell.colLinkId + '" ' +
                'class="' + objCell.classes + '">' +
                objCell.contentHtml +
                '</td>';
        }
        return rc;
    }


    //--------------------------------------------------------------------------
    // Serializes the <thead>: one <tr> per header row, the leading check-all
    // cell on the first row, then that row's header cells.
    //--------------------------------------------------------------------------
    function pvSerializeHeader(objModel_) {
        var rc = '<thead class="' + objModel_.headerRowClass + '">',
            idxHeaderRow,
            objCheckAll = objModel_.checkAllHeaderCell;
        for(idxHeaderRow = 0;
                idxHeaderRow < objModel_.headerRows.length;
                ++idxHeaderRow) {
            rc += '<tr' + (idxHeaderRow ? ' class="grouped-header"' : '') + '>';
            if(!idxHeaderRow && objCheckAll) {
                rc +=
                    '<td ' +
                    (objCheckAll.rowSpan > 1 ?
                        'rowspan="' + objCheckAll.rowSpan + '" ' :
                        '') +
                    'class="' + objCheckAll.classes + '">' +
                    '<input ' +
                    'type="checkbox" ' +
                    'class="' + objCheckAll.inputClass + '"' +
                    'name="' + objCheckAll.name + '" ' +
                    'onclick="' + objCheckAll.onClickJs + '" />' +
                    '</td>';
            }
            rc += pvSerializeHeaderCells(objModel_.headerRows[idxHeaderRow]);
            rc += '</tr>';
        }
        return rc + '</thead>';
    }


    //--------------------------------------------------------------------------
    // Serializes a row's leading checkbox cell: the full <input> when the row
    // is checkable, or an empty <td> placeholder when it is not.
    //--------------------------------------------------------------------------
    function pvSerializeRowCheckbox(objCheckbox_) {
        if(!objCheckbox_) {
            return '<td></td>';
        }
        return '<td class="centerAlign">' +
            '<input' +
            ' type="checkbox" ' +
            ' name="' + objCheckbox_.name + '"' +
            ' id="' + objCheckbox_.id + '"' +
            ' value="' + objCheckbox_.value + '"' +
            (objCheckbox_.disabled ? ' disabled="disabled"' : '') +
            (objCheckbox_.checked ? ' checked="checked"' : '') +
            objCheckbox_.additionalAttributes +
            ' onclick="' + objCheckbox_.onClickJs + '"/>' +
            '</td>';
    }


    //--------------------------------------------------------------------------
    // Serializes a single body cell. Note the deliberate quirks preserved from
    // the original string builder: the onclick attribute has no leading space,
    // and a dialog link wraps the content in an <a href> inside any <label>.
    //--------------------------------------------------------------------------
    function pvSerializeBodyCell(objCell_) {
        var strInner =
                objCell_.linkHref ?
                    '<a href="' + objCell_.linkHref + '">' +
                        objCell_.contentHtml + '</a>' :
                    objCell_.contentHtml;
        return '<td' +
            (objCell_.cellId ? ' id="' + objCell_.cellId + '"' : '') +
            (objCell_.classes ? ' class="' + objCell_.classes + '"' : '') +
            (objCell_.onClickJs ? 'onclick="' + objCell_.onClickJs + '"' : '') +
            (objCell_.colSpan === 1 ? '' : ' colspan="' + objCell_.colSpan + '"') +
            (objCell_.rowSpan === 1 ? '' : ' rowspan="' + objCell_.rowSpan + '"') +
            '>' +
            (objCell_.labelFor ? '<label for="' + objCell_.labelFor + '">' : '') +
            strInner +
            (objCell_.labelFor ? '</label>' : '') +
            '</td>';
    }


    //--------------------------------------------------------------------------
    // Serializes the body rows. Mirrors the original builder exactly, including
    // its quirk of emitting a single closing </tr> after all rows rather than
    // one per row.
    //--------------------------------------------------------------------------
    function pvSerializeBodyRows(objModel_) {
        var rc = '',
            idxRow,
            objRow,
            idxCell;
        for(idxRow = 0; idxRow < objModel_.bodyRows.length; ++idxRow) {
            objRow = objModel_.bodyRows[idxRow];
            rc +=
                '<tr ' +
                'class="' + objRow.primaryClass + objRow.additionalClasses + '"' +
                objRow.additionalAttrs + '>';
            if(objModel_.hasCheckboxColumn) {
                rc += pvSerializeRowCheckbox(objRow.checkbox);
            }
            for(idxCell = 0; idxCell < objRow.cells.length; ++idxCell) {
                rc += pvSerializeBodyCell(objRow.cells[idxCell]);
            }
        }
        //  The original builder closes only once, after every row.
        return rc + '</tr>';
    }


    //--------------------------------------------------------------------------
    // Serializes the single full-width row shown when there is no data.
    //--------------------------------------------------------------------------
    function pvSerializeNoDataRow(objFullWidthMessage_) {
        if(objFullWidthMessage_.colSpan > 0) {
            return '<tr><td colspan="' + objFullWidthMessage_.colSpan +
                '" class="centerAlign' +
                (objFullWidthMessage_.cssClass ?
                    ' ' + objFullWidthMessage_.cssClass :
                    '') +
                '">' + objFullWidthMessage_.contentHtml + '</td>';
        }
        return '<tr><td' +
            (objFullWidthMessage_.cssClass ?
                ' class="' + objFullWidthMessage_.cssClass + '"' :
                '') +
            '>' + objFullWidthMessage_.contentHtml + '</td>';
    }


    //--------------------------------------------------------------------------
    // Turns the pure view-model into the HTML string. This is the single
    // HTML-emitting boundary; all data/structure decisions live in
    // pvBuildTableViewModel, and this function only stringifies them.
    //--------------------------------------------------------------------------
    function pvSerializeTableViewModel(objModel_) {
        var rc;
        if(!objModel_.render) {
            return objModel_.fullWidthMessage.contentHtml;
        }
        rc =
            '<table ' +
            'class="' + objModel_.tableClass + '" ' +
            'data-mwClientTable="1" ' +
            'data-cssClassPrefix="' + objModel_.cssClassPrefix + '" ' +
            (objModel_.tableId ? "id='" + objModel_.tableId + "'" : '') + '>';
        if(!objModel_.suppressHeader) {
            rc += pvSerializeHeader(objModel_);
        }
        if(!objModel_.bodyRows.length) {
            rc += pvSerializeNoDataRow(objModel_.fullWidthMessage);
        } else {
            rc += pvSerializeBodyRows(objModel_);
        }
        return rc + '</table>';
    }


    //--------------------------------------------------------------------------
    // Builds a table's HTML by describing it as a pure view-model and then
    // serializing that model - the data/structure decisions and the HTML
    // emission are now two separately testable steps.
    //--------------------------------------------------------------------------
    function pbBuildTableForArray(objTable_, array_, objBuildOptions_) {
        return pvSerializeTableViewModel(
            pvBuildTableViewModel(objTable_, array_, objBuildOptions_));
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvFilterTableRows(table_, fnFilterRow_) {
        var idxRow,
            tr,
            idxVisibile = 0,

            // Check if the table was built using a style class prefix...
            strCssClassPrefix = pvGetTableCssClass(table_);

        for(idxRow = 0; idxRow < table_.rows.length; ++idxRow) {
            tr = table_.rows[idxRow];
            if(tr.parentNode.nodeName !== 'THEAD') {
                // Ignore header rows when filtering...

                if(fnFilterRow_(tr)) {
                    tr.style.display = '';
                    pvApplyOddOrEvenClassToRow(tr, idxVisibile, strCssClassPrefix);
                    ++idxVisibile;
                } else {
                    tr.style.display = 'none';
                }
            }
        }
    }


    //--------------------------------------------------------------------------
    // Filters rows to show if any cell in the row matches the filter text
    //--------------------------------------------------------------------------
    function pbFilterTableRowsToFilterText(table_, filterText_) {
        var tmpCellIndex,
            strCapitilizedFilterText = filterText_.toUpperCase();

        pvFilterTableRows(
            table_,
            function (objRow_) {
                for(tmpCellIndex = 0; tmpCellIndex < objRow_.cells.length; tmpCellIndex++) {
                    var objCell = objRow_.cells[tmpCellIndex];
                    if(objCell) {
                        var txtValue = objCell.textContent || objCell.innerText;
                        if(txtValue.toUpperCase().indexOf(strCapitilizedFilterText) > -1) {
                            return 1;
                        }
                    }
                }
                return 0;
            }
        );
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbRemoveTableRows(table_, fnShouldRemoveRow_) {
        var idxRow,
            tr,
            idxVisible = 0,
            // Check if the table was built using a style class prefix...
            strCssClassPrefix = pvGetTableCssClass(table_);

        for(idxRow = 0; idxRow < table_.rows.length; ++idxRow) {
            tr = table_.rows[idxRow];
            if(tr.parentNode.nodeName !== 'THEAD') {
                // Ignore header rows when removing...

                if(!fnShouldRemoveRow_(tr)) {
                    tr.style.display = '';
                    pvApplyOddOrEvenClassToRow(tr, idxVisible, strCssClassPrefix);
                    ++idxVisible;
                } else {
                    tr.remove();
                    //we've removed a row so we have to adjust our iterator
                    //so the striping will finish running
                    idxRow--;
                }
            }
        }
    }


    //--------------------------------------------------------------------------
    // Flattens the column tree to every column object - parents and leaves
    // alike - unlike pbFlattenColumnsToLeaves which returns leaves only. Both
    // grouped (parent) and leaf header cells carry a data-mwColLinkId, so
    // linking must be able to match a column object at any level.
    //--------------------------------------------------------------------------
    function pvFlattenColumnsToAllLevels(arrColumns_, optionalColumnArray_) {
        optionalColumnArray_ = optionalColumnArray_ || [];

        for(var idxColumn = 0; idxColumn < arrColumns_.length; ++idxColumn) {
            var objColumn = arrColumns_[idxColumn];
            optionalColumnArray_.push(objColumn);
            if(objColumn.arrSubColumns && objColumn.arrSubColumns.length) {
                pvFlattenColumnsToAllLevels(objColumn.arrSubColumns, optionalColumnArray_);
            }
        }

        return optionalColumnArray_;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbLinkTableObjectsToElement(objTable_, objTableAncestorElement_) {
        var arrColumns = pvFlattenColumnsToAllLevels(objTable_.arrColumns),
            tmpIsTableElement =
                '1' === objTableAncestorElement_.getAttribute('data-mwClientTable'),
            objTableElement =
                tmpIsTableElement ? objTableAncestorElement_ : objTableAncestorElement_.querySelector('*[data-mwClientTable="1"]'),
            arrColumnElements,
            idxColumnElem,
            strColLinkId,
            objColumnElem,
            idxColumnObj;

        if(objTableElement) {
            mjtElemData(objTableElement, 'data-mwClientTableObject', objTable_);

            arrColumnElements = objTableElement.querySelectorAll('[data-mwColLinkId]');
            for(idxColumnElem = 0; idxColumnElem < arrColumnElements.length; ++idxColumnElem) {
                objColumnElem = arrColumnElements[idxColumnElem];
                strColLinkId = objColumnElem.getAttribute('data-mwColLinkId');

                if(strColLinkId) {
                    for(idxColumnObj = 0; idxColumnObj < arrColumns.length; ++idxColumnObj) {
                        if(arrColumns[idxColumnObj].colLinkId === strColLinkId) {
                            mjtElemData(objColumnElem, 'data-mwColLinkObj', arrColumns[idxColumnObj]);
                        }
                    }
                }
            }
        }
    }


    //--------------------------------------------------------------------------
    // Single page-wide click handler for sortable column headers. Replaces the
    // former per-cell inline onclick: it works for any number of tables on the
    // page (including dynamically inserted / re-rendered ones) with no required
    // per-consumer wiring. pbSortClientColumn resolves the table by walking up to
    // the nearest TABLE, and prefers the live linked column object (so a linked
    // table's fnCustomSort still runs); the serialized sortInfo is the fallback.
    //
    // This runs on every document click, so it resolves the header with a
    // single native closest() call and bails immediately for the overwhelming
    // majority of clicks that are not inside a sortable header.
    //--------------------------------------------------------------------------
    function pvOnDocumentSortClick(event_) {
        var objTarget = getEventElement(event_),
            objHeaderCell = objTarget && objTarget.closest('[data-mwSortInfo]');
        if(objHeaderCell) {
            pbSortClientColumn(
                objHeaderCell,
                JSON.parse(unescape(objHeaderCell.getAttribute('data-mwSortInfo'))),
                pvGetTableCssClass(objHeaderCell));
        }
    }

    if(document.addEventListener) {
        document.addEventListener('click', pvOnDocumentSortClick);
    }


    //--------------------------------------------------------------------------
    // Default data transport: adapts the table's simplified transport signature
    // (command_, payload_, fnOnSuccess_, doingWhat_) onto the existing remote-
    // scripting mechanism. This is the only place the jsrsExecuteWithErrorP /
    // rsCallbackHandleStandardJSONResponse globals are touched, so tests can swap
    // in their own transport via dataSource.fnTransport and never hit them.
    //--------------------------------------------------------------------------
    function pvDefaultDataTransport(params_) {
        jsrsExecuteWithErrorP(
            params_.command,
            rsCallbackHandleStandardJSONResponse,
            params_.doingWhat,
            params_.payload,
            // The loading indicator is rendered inline in the table's own
            // target element (see pbLoadTableData), so we suppress the global
            // side effects of the remote-scripting call:
            //  - skipInfoMessage: no global floating "doing what" message, so
            //    multiple self-loading tables on one page don't collide on a
            //    single shared message.
            //  - skipDisableDialogButtons: a table fetching its own rows must
            //    not disable the buttons of a dialog it happens to live in.
            //  - rsErrorCallback: render load failures as an inline error row in
            //    the table (see pbLoadTableData) instead of the global error
            //    dialog + page refresh, keeping the failure local to this table.
            {
                fnOnSuccess: params_.fnOnSuccess,
                skipInfoMessage: true,
                skipDisableDialogButtons: true,
                rsErrorCallback: function (responseString_) {
                    if(params_.fnOnError) {
                        params_.fnOnError(responseString_);
                    }
                }
            });
    }


    //--------------------------------------------------------------------------
    // Builds the default inline loading indicator shown in the target element
    // while a load is in flight: the full table shell with its column headers,
    // plus a single full-width row carrying the loading message. Rendering the
    // headers up front keeps the table from jumping when the rows arrive.
    // Consumers can override the markup entirely via dataSource.loadingHtml.
    //--------------------------------------------------------------------------
    function pvBuildLoadingHtml(objTable_) {
        var objDataSource = objTable_.dataSource || {},
            strSpinner =
                '<span class="fa-spin FontAwesomeIcon" style="display:inline-block">&#' +
                    getRawFontId(FontIconId_Enum.fiiSpinner) + ';</span>',
            strLoadingText = objDataSource.doingWhat || 'Loading...';
        return pbBuildTableForArray(objTable_, [], {
            forceShowTable: true,
            // Raw markup so the spinner span isn't encoded; the text is encoded.
            fullWidthMessageHtml: strSpinner + ' ' + htmlEncode(strLoadingText),
            fullWidthMessageClass: 'mwClientTableLoading'
        });
    }


    //--------------------------------------------------------------------------
    // Resolves the message to show when a load fails. A consumer can derive it
    // from the error via dataSource.fnBuildErrorMessage, supply a static
    // dataSource.errorMessage, or fall back to a generic default.
    //--------------------------------------------------------------------------
    function pvBuildErrorMessage(objTable_, objDataSource_, error_) {
        if(objDataSource_.fnBuildErrorMessage) {
            return objDataSource_.fnBuildErrorMessage({
                table: objTable_,
                dataSource: objDataSource_,
                error: error_
            });
        }
        return objDataSource_.errorMessage || 'Error loading data.';
    }


    //--------------------------------------------------------------------------
    // Builds the inline error indicator shown in the target element when a load
    // fails: the same table shell + headers as the loading state, with a single
    // full-width row carrying the error message in place of the loading message.
    //--------------------------------------------------------------------------
    function pvBuildErrorHtml(objTable_, strMessage_) {
        return pbBuildTableForArray(objTable_, [], {
            forceShowTable: true,
            fullWidthMessage: strMessage_,
            // 'errorText' is the project-wide inline error-text style (red,
            // bold); 'mwClientTableError' is a module hook parallel to the
            // loading row's class.
            fullWidthMessageClass: 'mwClientTableError errorText'
        });
    }


    //--------------------------------------------------------------------------
    // True when the table is configured for (server-side) paging.
    //--------------------------------------------------------------------------
    function pvIsPaged(objTable_) {
        return !!(objTable_.paging && objTable_.paging.pageSize);
    }


    //--------------------------------------------------------------------------
    // True when the table pages by appending ("load more").
    //--------------------------------------------------------------------------
    function pvIsAppendPaged(objTable_) {
        return pvIsPaged(objTable_) && objTable_.paging.mode === 'append';
    }


    //--------------------------------------------------------------------------
    // Is there more to load in append mode? True until the server hands back a
    // short (< pageSize) page - i.e. it has run out of not-yet-seen rows. This
    // is deliberately NOT loadedCount < totalCount: the seen-set / exclude-then-
    // take paging can let the loaded count and the server's total count drift
    // apart (e.g. a row's group membership changes mid-browse), which would
    // strand the Load more button on-screen or hide it while rows remain. The
    // short-page signal comes straight from what the server returned, so it
    // stays correct regardless of that drift. Drives whether Load more is shown.
    //--------------------------------------------------------------------------
    function pvHasMoreToLoad(control_) {
        return !control_.reachedEnd;
    }


    //--------------------------------------------------------------------------
    // Builds the inner content of the "load more" control (append paging): a
    // "(Rows 1 to X of N)" record-count indicator plus a Load more button, which
    // is omitted once every row has been loaded. The record count matches the
    // "pageRecordCountOnly" style used by the server-generated report tables
    // (append always shows rows 1..X, since no rows are ever discarded). Kept
    // separate from the wrapper so the wrapper (which carries the table link the
    // button's onclick resolves) can be rebuilt in place on each append without
    // being relinked.
    //--------------------------------------------------------------------------
    function pvBuildLoadMoreControlContent(control_, tmpBusy_, strErrorMessage_) {
        var tmpLoadedCount = control_.loadedCount,
            tmpTotalCount = control_.totalCount,
            tmpFirstRow = tmpTotalCount > 0 ? 1 : 0,
            strTrailing,
            strError = '';
        if(tmpBusy_) {
            // While a page is fetching, swap the Load more button for a spinner
            // so the click gives immediate feedback.
            strTrailing =
                '<span class="mwClientTableLoadMoreSpinner">' +
                    '<span class="fa-spin FontAwesomeIcon" style="display:inline-block">&#' +
                        getRawFontId(FontIconId_Enum.fiiSpinner) + ';</span>' +
                '</span>';
        } else if(pvHasMoreToLoad(control_)) {
            strTrailing = pvBuildLoadMoreButton();
        } else {
            strTrailing = '';
        }
        if(strErrorMessage_) {
            // Inline error after a failed "Load more". The button above is kept
            // (has-more is still true, since a failed page loads no rows), so the
            // user can retry. Encoded - the message may carry server text.
            strError =
                '<span class="mwClientTableError errorText">' +
                    htmlEncode(strErrorMessage_) +
                '</span>';
        }
        return '<span class="nowrap mwClientTableLoadMoreInfo">' +
                '<span class="pageRecordCountOnly">' +
                    '(Rows ' + tmpFirstRow + ' to ' + tmpLoadedCount +
                    ' of ' + tmpTotalCount + ')' +
                '</span>' +
            '</span>' +
            strTrailing +
            strError;
    }


    //--------------------------------------------------------------------------
    // Builds the "Load more" button. type="button" so it never submits a form;
    // its onclick resolves the owning table (via the wrapper's link) and appends
    // the next page - see MWTable.PROTECTED.doLoadMore.
    //--------------------------------------------------------------------------
    function pvBuildLoadMoreButton() {
        return '<button' +
                ' type="button"' +
                ' class="mwButton neutral paddingSmall marginLeftSmall"' +
                ' onclick="MWTable.PROTECTED.doLoadMore(this)">' +
            'Load more' +
            '</button>';
    }


    //--------------------------------------------------------------------------
    // Builds the load-more control wrapper, rendered as a sibling of the table.
    // Its Load more button is driven by an inline onclick (pvBuildLoadMoreButton
    // -> MWTable.PROTECTED.doLoadMore).
    //--------------------------------------------------------------------------
    function pvBuildLoadMoreHtml(control_) {
        return '<div class="mwClientTableLoadMore">' +
            pvBuildLoadMoreControlContent(control_) +
            '</div>';
    }


    //--------------------------------------------------------------------------
    // Links the live table object to the load-more wrapper so the button's
    // onclick (ptDoLoadMore) can resolve the table it belongs to.
    //--------------------------------------------------------------------------
    function pvLinkLoadMore(objTable_, objTargetElement_) {
        var objControl = objTargetElement_.querySelector('.mwClientTableLoadMore');
        if(objControl) {
            mjtElemData(objControl, 'data-mwClientTableObject', objTable_);
        }
    }


    //--------------------------------------------------------------------------
    // Rebuilds the load-more control's contents in place (updating the "(Rows 1
    // to X of N)" count and dropping the button when exhausted) after an append,
    // leaving the wrapper - and its table link - intact.
    //--------------------------------------------------------------------------
    function pvRefreshLoadMoreControl(objTargetElement_, control_) {
        var objControl = objTargetElement_.querySelector('.mwClientTableLoadMore');
        if(objControl) {
            HtmlUtilities.setElementContents({
                element: objControl,
                htmlContents: pvBuildLoadMoreControlContent(control_)
            });
        }
    }


    //--------------------------------------------------------------------------
    // Puts the load-more control into its "fetching" state: the Load more button
    // is replaced with a spinner. The success/error handlers rebuild the control
    // afterward, clearing this state.
    //--------------------------------------------------------------------------
    function pvSetLoadMoreBusy(objTargetElement_, control_) {
        var objControl = objTargetElement_.querySelector('.mwClientTableLoadMore');
        if(objControl) {
            HtmlUtilities.setElementContents({
                element: objControl,
                htmlContents: pvBuildLoadMoreControlContent(control_, true)
            });
        }
    }


    //--------------------------------------------------------------------------
    // Appends one freshly fetched page's rows to the table already rendered in
    // the target element, without disturbing the rows (and their live DOM state)
    // already there. The page is built as a throwaway table so it reuses the
    // exact row-building code path - offset by the rows already loaded so ids and
    // field names stay unique - and its data rows are then moved into the live
    // table. Header rows (inside <thead>) are left behind.
    //--------------------------------------------------------------------------
    function pvAppendPageRows(
            objTable_, objTargetElement_, array_, tmpIndexOffset_, tmpMarkChunkStart_) {
        var objLiveTable = objTargetElement_.querySelector('[data-mwClientTable="1"]'),
            objScratch,
            objBuiltTable,
            objRowContainer,
            arrRows,
            objRow,
            tmpIsFirstDataRow = true,
            idxRow;
        if(!objLiveTable || !array_ || !array_.length) {
            return;
        }
        objScratch = document.createElement('div');
        HtmlUtilities.setElementContents({
            element: objScratch,
            htmlContents: pbBuildTableForArray(objTable_, array_, {
                indexOffset: tmpIndexOffset_,
                forceShowTable: true
            })
        });
        objBuiltTable = objScratch.querySelector('[data-mwClientTable="1"]');
        if(!objBuiltTable) {
            return;
        }
        // The browser normalizes the built markup, wrapping the data rows in a
        // <tbody>, so append into the live table's <tbody> if it has one (falling
        // back to the table itself). appendChild moves rather than copies.
        objRowContainer =
            objLiveTable.querySelector('tbody') || objLiveTable;
        arrRows = objBuiltTable.querySelectorAll('tr');
        for(idxRow = 0; idxRow < arrRows.length; ++idxRow) {
            objRow = arrRows[idxRow];
            // Skip the header rows (which live in <thead>); move the data rows.
            if(objRow.parentNode &&
                    objRow.parentNode.tagName &&
                    objRow.parentNode.tagName.toUpperCase() === 'THEAD') {
                continue;
            }
            // Tag the first row of this chunk so a CSS rule (border-top) can draw
            // a separator between load-more chunks. A marker class, not a spacer
            // row, so striping/sorting and per-row re-wiring are undisturbed.
            if(tmpMarkChunkStart_ && tmpIsFirstDataRow) {
                objRow.className =
                    trim(objRow.className + ' mwClientTableChunkStart');
            }
            tmpIsFirstDataRow = false;
            objRowContainer.appendChild(objRow);
        }
    }


    //--------------------------------------------------------------------------
    // Notifies the consumer (via dataSource.fnOnRowsRendered) that rows have
    // just been rendered or appended into the target element, so it can wire up
    // per-row behavior that isn't baked into the built markup - and, crucially,
    // re-apply it to rows added by a later loadMore(). Called after every full
    // render and after every append.
    //--------------------------------------------------------------------------
    function pvNotifyRowsRendered(objTable_, objTargetElement_) {
        var objDataSource = objTable_.dataSource || {};
        if(objDataSource.fnOnRowsRendered) {
            objDataSource.fnOnRowsRendered(objTargetElement_);
        }
    }


    //--------------------------------------------------------------------------
    // Builds a real-DOM renderer for the paging controller: the adapter that
    // turns the controller's DOM-free render calls into actual writes to the
    // target element, reusing the module's existing HTML/DOM helpers. The
    // controller owns all paging state and decides what to render; this object
    // only knows how to paint it. control_ is the controller's read-only state
    // snapshot ({mode, pageIndex, pageSize, totalCount, loadedCount}).
    //--------------------------------------------------------------------------
    function pvCreateDomRenderer(objTable_, objTargetElement_) {
        var objDataSource = objTable_.dataSource || {};
        return {
            // A full (re)render of the current page: build the table, append the
            // load-more control (append mode), inject, then relink the live
            // column objects and the control. Row-rendered notification is driven
            // by the controller (after both render and append), so it isn't fired
            // here.
            renderPage: function (arrRows_, control_) {
                var strHtml = pbBuildTableForArray(objTable_, arrRows_);
                if(control_.mode === 'append') {
                    strHtml += pvBuildLoadMoreHtml(control_);
                }
                HtmlUtilities.setElementContents({
                    element: objTargetElement_,
                    htmlContents: strHtml
                });
                pbLinkTableObjectsToElement(objTable_, objTargetElement_);
                if(control_.mode === 'append') {
                    pvLinkLoadMore(objTable_, objTargetElement_);
                }
            },
            // Appends a fetched page's rows to those already shown (append mode),
            // preserving the live DOM state of the existing rows. (The controller
            // passes its state snapshot too, but the append itself doesn't need
            // it - the load-more control is refreshed separately.) When the table
            // opts into chunkSeparator, the first row of each appended chunk is
            // tagged so CSS can draw a divider between load-more chunks.
            appendRows: function (arrRows_, tmpOffset_) {
                pvAppendPageRows(
                    objTable_,
                    objTargetElement_,
                    arrRows_,
                    tmpOffset_,
                    !!(objTable_.paging && objTable_.paging.chunkSeparator));
            },
            // First-load fallback: nothing is rendered yet, so show the full
            // inline loading table (consumer markup wins if supplied).
            showLoading: function () {
                HtmlUtilities.setElementContents({
                    element: objTargetElement_,
                    htmlContents:
                        objDataSource.loadingHtml || pvBuildLoadingHtml(objTable_)
                });
            },
            // Replaces the loading row with an inline error row.
            showError: function (strMessage_) {
                HtmlUtilities.setElementContents({
                    element: objTargetElement_,
                    htmlContents: pvBuildErrorHtml(objTable_, strMessage_)
                });
            },
            // Swaps the Load more button for a spinner while a page is fetching.
            setLoadMoreBusy: function (control_) {
                pvSetLoadMoreBusy(objTargetElement_, control_);
            },
            // Rebuilds the load-more control's contents in place after an append.
            refreshControl: function (control_) {
                pvRefreshLoadMoreControl(objTargetElement_, control_);
            },
            // Surfaces an append failure on the load-more control, leaving the
            // already-loaded rows untouched. Rebuilds the control so the "Load
            // more" button is retained (the failed page can be retried) with the
            // error shown inline beside it.
            loadMoreError: function (strMessage_, control_) {
                var objControl =
                    objTargetElement_.querySelector('.mwClientTableLoadMore');
                if(objControl) {
                    HtmlUtilities.setElementContents({
                        element: objControl,
                        htmlContents:
                            pvBuildLoadMoreControlContent(
                                control_, false, strMessage_)
                    });
                }
            },
            notifyRowsRendered: function () {
                pvNotifyRowsRendered(objTable_, objTargetElement_);
            }
        };
    }


    //--------------------------------------------------------------------------
    // Builds the mapper for the paging controller: adapts the dataSource's
    // consumer-supplied callbacks (fnBuildPayload/fnExtractArray/
    // fnExtractTotalCount/fnGetRowKey/fnBuildErrorMessage) to the narrow shape
    // the controller calls, keeping the {table, dataSource, ...} envelope the
    // consumer expects. Absent an fnExtractTotalCount the row count falls back
    // to the number of rows returned.
    //--------------------------------------------------------------------------
    function pvCreateDataSourceMapper(objTable_) {
        var objDataSource = objTable_.dataSource || {};
        function pvExtractArray(json_) {
            return objDataSource.fnExtractArray ?
                objDataSource.fnExtractArray({
                    table: objTable_,
                    dataSource: objDataSource,
                    json: json_
                }) :
                json_;
        }
        return {
            // fnBuildPayload receives the live table, its dataSource config, and
            // the module-supplied request state (pageIndex/pageSize for a paged
            // table) so it can map them onto the server's own parameter names.
            // Without it the request state is sent through as the payload.
            buildPayload: function (objRequest_) {
                return objDataSource.fnBuildPayload ?
                    objDataSource.fnBuildPayload({
                        table: objTable_,
                        dataSource: objDataSource,
                        request: objRequest_
                    }) :
                    objRequest_;
            },
            extractArray: pvExtractArray,
            // No fnExtractTotalCount: fall back to the rows returned. Every real
            // paged/append consumer supplies fnExtractTotalCount (they need a
            // server-side total to page at all), so this is a defensive default
            // only - deliberately uniform across paged and append modes.
            extractTotalCount: function (json_, tmpLoadedCount_) {
                var arrRows;
                if(objDataSource.fnExtractTotalCount) {
                    return objDataSource.fnExtractTotalCount({
                        table: objTable_,
                        dataSource: objDataSource,
                        json: json_,
                        // Rows already loaded before this response's page. A
                        // consumer whose server returns the count still matching
                        // (exclusion paging) adds this to recover the full total;
                        // consumers whose server returns the grand total ignore it.
                        loadedCount: tmpLoadedCount_ || 0
                    });
                }
                arrRows = pvExtractArray(json_);
                return arrRows ? arrRows.length : 0;
            },
            getRowKey: objDataSource.fnGetRowKey,
            buildErrorMessage: function (error_) {
                return pvBuildErrorMessage(objTable_, objDataSource, error_);
            }
        };
    }


    //--------------------------------------------------------------------------
    // Builds the transport for the paging controller: adapts the controller's
    // narrow fn(payload, onSuccess, onError) call to the dataSource's
    // fnTransport (or the default remote-scripting transport), threading the
    // command/doingWhat/table/dataSource envelope those expect.
    //--------------------------------------------------------------------------
    function pvCreateDataSourceTransport(objTable_) {
        var objDataSource = objTable_.dataSource || {},
            fnTransport = objDataSource.fnTransport || pvDefaultDataTransport;
        return function (objPayload_, fnOnSuccess_, fnOnError_) {
            fnTransport({
                table: objTable_,
                dataSource: objDataSource,
                command: objDataSource.command,
                payload: objPayload_,
                doingWhat: objDataSource.doingWhat,
                fnOnSuccess: fnOnSuccess_,
                fnOnError: fnOnError_
            });
        };
    }


    //--------------------------------------------------------------------------
    // Builds a paging controller wired to a real-DOM renderer over the given
    // target element and stores it on the table, so subsequent calls
    // (reload/loadMore) drive the same controller instance - and thus the same
    // load-token staleness guard and de-dup state. The paging mode is derived
    // from the table's config: 'append' (load-more) or undefined (a plain
    // non-paged self-load).
    //--------------------------------------------------------------------------
    function pvBuildControllerForTable(objTable_, objTargetElement_) {
        var strMode = pvIsAppendPaged(objTable_) ? 'append' : undefined,
            objController = pvCreatePagingController({
                mode: strMode,
                pageSize: objTable_.paging ? objTable_.paging.pageSize : undefined,
                transport: pvCreateDataSourceTransport(objTable_),
                mapper: pvCreateDataSourceMapper(objTable_),
                renderer: pvCreateDomRenderer(objTable_, objTargetElement_)
            });
        objTable_._pagingController = objController;
        return objController;
    }


    //--------------------------------------------------------------------------
    // The self-loading paging controller: a DOM-free state machine (page index,
    // counts, load-token staleness, cross-page de-dup) that orchestrates loads
    // behind two injected ports - a transport (fetch) and a renderer (all DOM
    // and HTML). Callers (the pb* loaders) build one with a real-DOM renderer;
    // tests build one with fakes to verify orchestration without a DOM.
    //
    // params_: {
    //   mode:      'append' | undefined,
    //   pageSize:  number | undefined,
    //   transport: fn(payload_, fnOnSuccess_, fnOnError_),
    //   mapper:    { buildPayload(request_), extractArray(json_),
    //               extractTotalCount(json_), getRowKey(row_)?,
    //               buildErrorMessage(error_) },
    //   renderer:  { renderPage(rows_, control_), appendRows(rows_, offset_,
    //               control_), showLoading(), showError(msg_),
    //               setLoadMoreBusy(control_), loadMoreError(msg_, control_),
    //               notifyRowsRendered() }
    // }
    //--------------------------------------------------------------------------
    function pvCreatePagingController(params_) {
        var strMode = params_.mode,
            tmpPageSize = params_.pageSize,
            fnTransport = params_.transport,
            objMapper = params_.mapper,
            objRenderer = params_.renderer,
            tmpPageIndex = 0,
            tmpTotalCount = 0,
            tmpLoadedCount = 0,
            tmpLoadToken = 0,
            // Append mode has reached the end when the server last returned a
            // short (< pageSize) page - no more not-yet-seen rows to fetch. This
            // drives has-more instead of comparing loadedCount to totalCount,
            // which the seen-set / exclude approach can let drift apart.
            tmpReachedEnd = false,
            // Keys of every row rendered so far (append mode), used to drop a
            // row a later page re-serves when the result set shifts. Prefixed
            // 'k:' so a key matching an Object.prototype member can't false-hit.
            objSeenKeys = {};

        // A read-only snapshot of the paging state handed to the renderer so it
        // can draw the pager / load-more control without reaching into the
        // controller's internals.
        function pvControl() {
            return {
                mode: strMode,
                pageIndex: tmpPageIndex,
                pageSize: tmpPageSize,
                totalCount: tmpTotalCount,
                loadedCount: tmpLoadedCount,
                reachedEnd: tmpReachedEnd
            };
        }

        function pvRecordSeenKeys(arrRows_) {
            var fnGetRowKey = objMapper.getRowKey,
                idxRow;
            if(!fnGetRowKey || !arrRows_) {
                return;
            }
            for(idxRow = 0; idxRow < arrRows_.length; ++idxRow) {
                objSeenKeys['k:' + fnGetRowKey(arrRows_[idxRow])] = true;
            }
        }

        // Returns arrRows_ with any row whose key was already rendered removed;
        // returns it unchanged when the mapper supplies no getRowKey.
        function pvFilterUnseenRows(arrRows_) {
            var fnGetRowKey = objMapper.getRowKey,
                arrRC,
                idxRow,
                objRow;
            if(!fnGetRowKey || !arrRows_) {
                return arrRows_;
            }
            arrRC = [];
            for(idxRow = 0; idxRow < arrRows_.length; ++idxRow) {
                objRow = arrRows_[idxRow];
                if(!objSeenKeys['k:' + fnGetRowKey(objRow)]) {
                    arrRC.push(objRow);
                }
            }
            return arrRC;
        }

        // The keys of every row rendered so far (append mode), with the 'k:'
        // prefix stripped. A consumer can send these to the server so it returns
        // the next page by excluding rows already loaded (see pvRequestState).
        function pvKnownKeys() {
            var arrRC = [],
                strPrefixedKey;
            for(strPrefixedKey in objSeenKeys) {
                if(Object.prototype.hasOwnProperty.call(
                        objSeenKeys, strPrefixedKey)) {
                    arrRC.push(strPrefixedKey.substring(2));
                }
            }
            return arrRC;
        }

        // Renders a full (first) page. For append mode this is where the loaded
        // count and the seen-key set are (re)initialised, so a reload or a
        // re-seed de-dups afresh from this page.
        function pvFreshRender(arrRows_) {
            if(strMode === 'append') {
                tmpLoadedCount = arrRows_ ? arrRows_.length : 0;
                objSeenKeys = {};
                pvRecordSeenKeys(arrRows_);
                // A first/seed page shorter than a full page means the server has
                // no more rows to give - so there is nothing more to load.
                tmpReachedEnd = !arrRows_ || arrRows_.length < tmpPageSize;
            }
            objRenderer.renderPage(arrRows_, pvControl());
            objRenderer.notifyRowsRendered();
        }

        // The request state handed to mapper.buildPayload so the consumer can
        // map it onto the server's own parameter names.
        function pvRequestState(tmpForPageIndex_) {
            if(!strMode) {
                return {};
            }
            var objRC = {
                pageIndex:
                    tmpForPageIndex_ === undefined ?
                        tmpPageIndex :
                        tmpForPageIndex_,
                pageSize: tmpPageSize
            };
            // Append mode also exposes the already-loaded row keys, so a consumer
            // can ask the server for the next page by exclusion (rows it doesn't
            // already have) rather than by offset - robust to the result set
            // changing between "load more" clicks. pageIndex stays available for
            // consumers/pagers that page positionally.
            if(strMode === 'append') {
                objRC.knownKeys = pvKnownKeys();
            }
            return objRC;
        }

        function pvFetchCurrentPage() {
            var objPayload = objMapper.buildPayload(pvRequestState()),
                tmpFetchToken;
            // Guard against out-of-order responses when loads overlap (rapid
            // filter changes, or a reload fired before the previous response
            // returns). Each fetch claims a monotonically increasing token; a
            // response only acts while its token is still the latest, so a slower
            // earlier load can't clobber the result of a newer one.
            tmpLoadToken += 1;
            tmpFetchToken = tmpLoadToken;
            // Show the inline loading state while the first-load / reload fetch
            // runs. (Append's later pages are pulled via loadMore, which shows
            // its own busy state on the Load more control instead.)
            objRenderer.showLoading();
            fnTransport(
                objPayload,
                function (json_) {
                    if(tmpFetchToken !== tmpLoadToken) {
                        return;
                    }
                    var arrRows = objMapper.extractArray(json_);
                    if(strMode) {
                        tmpTotalCount = objMapper.extractTotalCount(json_, tmpLoadedCount);
                    }
                    pvFreshRender(arrRows);
                },
                function (error_) {
                    if(tmpFetchToken !== tmpLoadToken) {
                        return;
                    }
                    objRenderer.showError(objMapper.buildErrorMessage(error_));
                });
        }

        function pvLoadFirst() {
            tmpPageIndex = 0;
            // A fresh load (initial or reload/refresh) starts the seen-set over,
            // so its request excludes nothing and the server returns the first
            // page. pvFreshRender re-records the returned page's keys on success.
            objSeenKeys = {};
            tmpLoadedCount = 0;
            pvFetchCurrentPage();
        }

        // Fetches the next page and appends only its genuinely-new rows to those
        // already shown, preserving their live DOM state. Unlike a page fetch
        // this never re-renders, and it surfaces failures on the load-more
        // control rather than replacing the rows. A safe no-op once everything
        // is loaded, or when the table isn't append-paged. has-more is the
        // module-level pure function of the control snapshot, shared with the
        // load-more renderer.
        function pvLoadMore() {
            var tmpFetchToken,
                tmpNextPageIndex;
            if(strMode !== 'append' || !pvHasMoreToLoad(pvControl())) {
                return;
            }
            // Request the next page WITHOUT committing the page index yet - it is
            // only advanced once the page actually arrives (success handler), so
            // a failed load can be retried for the same page rather than silently
            // skipping it.
            tmpNextPageIndex = tmpPageIndex + 1;
            // Same monotonic load-token guard pvFetchCurrentPage uses: a newer
            // load - another loadMore, or a reload / filter change - invalidates
            // this one, so a slower earlier response can't append stale rows out
            // of order onto a table that has since moved on.
            tmpLoadToken += 1;
            tmpFetchToken = tmpLoadToken;
            objRenderer.setLoadMoreBusy(pvControl());
            fnTransport(
                objMapper.buildPayload(pvRequestState(tmpNextPageIndex)),
                function (json_) {
                    if(tmpFetchToken !== tmpLoadToken) {
                        return;
                    }
                    var arrRows = objMapper.extractArray(json_),
                        arrUnseen,
                        tmpOffset = tmpLoadedCount;
                    // The page arrived - now commit the advance.
                    tmpPageIndex = tmpNextPageIndex;
                    tmpTotalCount = objMapper.extractTotalCount(json_, tmpLoadedCount);
                    // A short page (fewer than pageSize rows back from the server)
                    // means the server has run out of not-yet-seen rows: stop
                    // offering Load more. Based on the raw server page, not the
                    // post-dedup count, so a rare drift re-serve can't end paging
                    // early. See pvHasMoreToLoad.
                    tmpReachedEnd = !arrRows || arrRows.length < tmpPageSize;
                    arrUnseen = pvFilterUnseenRows(arrRows);
                    objRenderer.appendRows(arrUnseen, tmpOffset, pvControl());
                    tmpLoadedCount += arrUnseen ? arrUnseen.length : 0;
                    pvRecordSeenKeys(arrUnseen);
                    objRenderer.refreshControl(pvControl());
                    objRenderer.notifyRowsRendered();
                },
                function (error_) {
                    if(tmpFetchToken !== tmpLoadToken) {
                        return;
                    }
                    // The page index was not advanced, so the failed page is
                    // retried (not skipped) on the next click. Rebuild the control
                    // with an inline error AND the retained Load more button.
                    objRenderer.loadMoreError(
                        objMapper.buildErrorMessage(error_),
                        pvControl());
                });
        }

        // Seeds the first page from data the caller already has (append mode),
        // rendering it and enabling loadMore() for later pages without fetching
        // page 0. tmpTotal_ is the full server-side match count so the load-more
        // control can show the range and hide itself once exhausted.
        function pvSeedFirstPage(arrRows_, tmpTotal_) {
            tmpPageIndex = 0;
            tmpTotalCount = tmpTotal_ || 0;
            pvFreshRender(arrRows_);
        }

        return {
            loadFirst: pvLoadFirst,
            reload: pvLoadFirst,
            loadMore: pvLoadMore,
            seedFirstPage: pvSeedFirstPage
        };
    }


    //--------------------------------------------------------------------------
    // Fetches the table's rows and renders them into objTargetElement_,
    // remembering it so reload()/pager navigation can re-fetch into the same
    // place. A fresh load always starts at the first page.
    //--------------------------------------------------------------------------
    function pbLoadTableData(objTable_, objTargetElement_) {
        if(!objTable_.dataSource) {
            throw new Error('MWClientTable.loadInto requires a dataSource option.');
        }
        // A fresh load always builds a new controller bound to this target and
        // starts at the first page; the controller owns all paging state, so a
        // reload() (which reuses this controller) collapses append paging back
        // to just the first page.
        pvBuildControllerForTable(objTable_, objTargetElement_).loadFirst();
    }


    //--------------------------------------------------------------------------
    // Seeds an append-paged table with a first page the caller already has in
    // hand - rendering it and wiring up loadMore() for subsequent pages -
    // without fetching page 0 itself. Use when something outside the table did
    // the initial search (e.g. to obtain data needed to build the columns, such
    // as which columns the result set warrants) and now wants the table to take
    // over paging. tmpTotalCount_ is the full server-side match count, so the
    // load-more control can show "(Rows 1 to X of N)" and hide itself once done.
    //--------------------------------------------------------------------------
    function pbShowFirstPage(objTable_, objTargetElement_, array_, tmpTotalCount_) {
        pvBuildControllerForTable(objTable_, objTargetElement_)
            .seedFirstPage(array_, tmpTotalCount_);
    }


    //--------------------------------------------------------------------------
    // Re-fetches into the element remembered by the last loadTableData call,
    // returning to the first page. Throws if the table has never been loaded.
    //--------------------------------------------------------------------------
    function pbReloadTableData(objTable_) {
        if(!objTable_._pagingController) {
            throw new Error('MWClientTable.reload() called before loadInto().');
        }
        objTable_._pagingController.reload();
    }


    //--------------------------------------------------------------------------
    // Loads and appends the next page (append paging). A safe no-op when every
    // row is already loaded, so a Load more click at the end does nothing.
    // Throws if the table has never been loaded.
    //--------------------------------------------------------------------------
    function pbLoadMore(objTable_) {
        if(!objTable_._pagingController) {
            throw new Error('MWClientTable.loadMore() called before loadInto().');
        }
        objTable_._pagingController.loadMore();
    }


    //--------------------------------------------------------------------------
    // Handles a click on a rendered "Load more" button. The button's inline
    // onclick calls this (via MWTable.PROTECTED.doLoadMore, passing the button):
    // resolve the owning table from the wrapper's link and append the next page.
    //--------------------------------------------------------------------------
    function ptDoLoadMore(objButtonElement_) {
        var objControl =
                objButtonElement_.closest('.mwClientTableLoadMore'),
            objTable =
                objControl && mjtElemData(objControl, 'data-mwClientTableObject');
        if(objTable) {
            pbLoadMore(objTable);
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    return {
        getFlattenedColumnCount: pbGetFlattenedColumnCount,
        flattenColumnToLeaves: pbFlattenColumnToLeaves,
        flattenColumnsToLeaves: pbFlattenColumnsToLeaves,
        buildCellContents: pbBuildCellContents,
        buildArrayOfHeaderRowColumnObjects: pbBuildArrayOfHeaderRowColumnObjects,
        buildTableForArray: pbBuildTableForArray,
        sortClientColumn: pbSortClientColumn,
        filterTableRowsToFilterText: pbFilterTableRowsToFilterText,
        removeTableRows: pbRemoveTableRows,
        linkTableObjectsToElement: pbLinkTableObjectsToElement,
        loadTableData: pbLoadTableData,
        reloadTableData: pbReloadTableData,
        showFirstPage: pbShowFirstPage,
        loadMore: pbLoadMore,
        PROTECTED: {
            doLoadMore: ptDoLoadMore
        },
        TEST: {
            buildTableViewModel: pvBuildTableViewModel,
            serializeTableViewModel: pvSerializeTableViewModel,
            createPagingController: pvCreatePagingController
        }
    };
}());