// settings

var defaults = {

explicitInitialization: false,

rowHeight: 25,

defaultColumnWidth: 80,

enableAddRow: false,

leaveSpaceForNewRows: false,

editable: false,

autoEdit: true,

enableCellNavigation: true,

enableColumnReorder: true,

asyncEditorLoading: false,

asyncEditorLoadDelay: 100,

forceFitColumns: false,

enableAsyncPostRender: false,

asyncPostRenderDelay: 60,

autoHeight: false,

editorLock: Slick.GlobalEditorLock,

showHeaderRow: false,

headerRowHeight: 25,

showTopPanel: false,

topPanelHeight: 25,

formatterFactory: null,

editorFactory: null,

cellFlashingCssClass: "flashing",

selectedCellCssClass: "selected",

multiSelect: true,

enableTextSelectionOnCells: false,

dataItemColumnValueExtractor: null,

fullWidthRows: false,

multiColumnSort: false,

defaultFormatter: defaultFormatter

};

var columnDefaults = {

name: "",

resizable: true,

sortable: false,

minWidth: 30,

rerenderOnResize: false,

headerCssClass: null

};

// scroller

var th; // virtual height

var h; // real scrollable height

var ph; // page height

var n; // number of pages

var cj; // "jumpiness" coefficient

var page = 0; // current page

var offset = 0; // current page offset

var scrollDir = 1;

// private

var initialized = false;

var $container;

var uid = "slickgrid_" + Math.round(1000000 * Math.random());

var self = this;

var $focusSink;

var $headerScroller;

var $headers;

var $headerRow, $headerRowScroller;

var $topPanelScroller;

var $topPanel;

var $viewport;

var $canvas;

var $style;

var stylesheet, columnCssRulesL, columnCssRulesR;

var viewportH, viewportW;

var canvasWidth;

var viewportHasHScroll, viewportHasVScroll;

var headerColumnWidthDiff = 0, headerColumnHeightDiff = 0, // border+padding

cellWidthDiff = 0, cellHeightDiff = 0;

var absoluteColumnMinWidth;

var numberOfRows = 0;

var activePosX;

var activeRow, activeCell;

var activeCellNode = null;

var currentEditor = null;

var serializedEditorValue;

var editController;

var rowsCache = {};

var renderedRows = 0;

var numVisibleRows;

var prevScrollTop = 0;

var scrollTop = 0;

var lastRenderedScrollTop = 0;

var prevScrollLeft = 0;

var avgRowRenderTime = 10;

var selectionModel;

var selectedRows = [];

var plugins = [];

var cellCssClasses = {};

var columnsById = {};

var sortColumns = [];

// async call handles

var h_editorLoader = null;

var h_render = null;

var h_postrender = null;

var postProcessedRows = {};

var postProcessToRow = null;

var postProcessFromRow = null;

// perf counters

var counter_rows_rendered = 0;

var counter_rows_removed = 0;

//////////////////////////////////////////////////////////////////////////////////////////////

// Initialization

function init() {

$container = $(container);

if ($container.length < 1) {

throw new Error("SlickGrid requires a valid container, " + container + " does not exist in the DOM.");

}

// calculate these only once and share between grid instances

maxSupportedCssHeight = maxSupportedCssHeight || getMaxSupportedCssHeight();

scrollbarDimensions = scrollbarDimensions || measureScrollbar();

options = $.extend({}, defaults, options);

columnDefaults.width = options.defaultColumnWidth;

// validate loaded JavaScript modules against requested options

if (options.enableColumnReorder && !$.fn.sortable) {

throw new Error("SlickGrid's 'enableColumnReorder = true' option requires jquery-ui.sortable module to be loaded");

}

editController = {

"commitCurrentEdit": commitCurrentEdit,

"cancelCurrentEdit": cancelCurrentEdit

};

$container

.empty()

.css("overflow", "hidden")

.css("outline", 0)

.addClass(uid)

.addClass("ui-widget");

// set up a positioning container if needed

if (!/relative|absolute|fixed/.test($container.css("position"))) {

$container.css("position", "relative");

}

$focusSink = $("<div tabIndex='0' hideFocus style='position:fixed;width:0;height:0;top:0;left:0;outline:0;'></div>").appendTo($container);

$headerScroller = $("<div class='slick-header ui-state-default' style='overflow:hidden;position:relative;' />").appendTo($container);

$headers = $("<div class='slick-header-columns' style='width:10000px; left:-1000px' />").appendTo($headerScroller);

$headerRowScroller = $("<div class='slick-headerrow ui-state-default' style='overflow:hidden;position:relative;' />").appendTo($container);

$headerRow = $("<div class='slick-headerrow-columns' />").appendTo($headerRowScroller);

$topPanelScroller = $("<div class='slick-top-panel-scroller ui-state-default' style='overflow:hidden;position:relative;' />").appendTo($container);

$topPanel = $("<div class='slick-top-panel' style='width:10000px' />").appendTo($topPanelScroller);

if (!options.showTopPanel) {

$topPanelScroller.hide();

}

if (!options.showHeaderRow) {

$headerRowScroller.hide();

}

$viewport = $("<div class='slick-viewport' style='width:100%;overflow:auto;outline:0;position:relative;;'>").appendTo($container);

$viewport.css("overflow-y", options.autoHeight ? "hidden" : "auto");

$canvas = $("<div class='grid-canvas' />").appendTo($viewport);

if (!options.explicitInitialization) {

finishInitialization();

}

}

function finishInitialization() {

if (!initialized) {

initialized = true;

viewportW = parseFloat($.css($container[0], "width", true));

// header columns and cells may have different padding/border skewing width calculations (box-sizing, hello?)

// calculate the diff so we can set consistent sizes

measureCellPaddingAndBorder();

// for usability reasons, all text selection in SlickGrid is disabled

// with the exception of input and textarea elements (selection must

// be enabled there so that editors work as expected); note that

// selection in grid cells (grid body) is already unavailable in

// all browsers except IE

disableSelection($headers); // disable all text selection in header (including input and textarea)

if (!options.enableTextSelectionOnCells) {

// disable text selection in grid cells except in input and textarea elements

// (this is IE-specific, because selectstart event will only fire in IE)

$viewport.bind("selectstart.ui", function (event) {

return $(event.target).is("input,textarea");

});

}

createColumnHeaders();

setupColumnSort();

createCssRules();

resizeCanvas();

bindAncestorScrollEvents();

$container

.bind("resize.slickgrid", resizeCanvas);

$viewport

.bind("scroll.slickgrid", handleScroll);

$headerScroller

.bind("contextmenu.slickgrid", handleHeaderContextMenu)

.bind("click.slickgrid", handleHeaderClick);

$focusSink

.bind("keydown.slickgrid", handleKeyDown);

$canvas

.bind("keydown.slickgrid", handleKeyDown)

.bind("click.slickgrid", handleClick)

.bind("dblclick.slickgrid", handleDblClick)

.bind("contextmenu.slickgrid", handleContextMenu)

.bind("draginit", handleDragInit)

.bind("dragstart", handleDragStart)

.bind("drag", handleDrag)

.bind("dragend", handleDragEnd)

.delegate(".slick-cell", "mouseenter", handleMouseEnter)

.delegate(".slick-cell", "mouseleave", handleMouseLeave);

}

}

function registerPlugin(plugin) {

plugins.unshift(plugin);

plugin.init(self);

}

function unregisterPlugin(plugin) {

for (var i = plugins.length; i >= 0; i--) {

if (plugins[i] === plugin) {

if (plugins[i].destroy) {

plugins[i].destroy();

}

plugins.splice(i, 1);

break;

}

}

}

function setSelectionModel(model) {

if (selectionModel) {

selectionModel.onSelectedRangesChanged.unsubscribe(handleSelectedRangesChanged);

if (selectionModel.destroy) {

selectionModel.destroy();

}

}

selectionModel = model;

if (selectionModel) {

selectionModel.init(self);

selectionModel.onSelectedRangesChanged.subscribe(handleSelectedRangesChanged);

}

}

function getSelectionModel() {

return selectionModel;

}

function getCanvasNode() {

return $canvas[0];

}

function measureScrollbar() {

var $c = $("<div style='position:absolute; top:-10000px; left:-10000px; width:100px; height:100px; overflow:scroll;'></div>").appendTo("body");

var dim = {

width: $c.width() - $c[0].clientWidth,

height: $c.height() - $c[0].clientHeight

};

$c.remove();

return dim;

}

function getCanvasWidth() {

var availableWidth = viewportHasVScroll ? viewportW - scrollbarDimensions.width : viewportW;

var rowWidth = 0;

var i = columns.length;

while (i--) {

rowWidth += (columns[i].width || columnDefaults.width);

}

return options.fullWidthRows ? Math.max(rowWidth, availableWidth) : rowWidth;

}

function updateCanvasWidth(forceColumnWidthsUpdate) {

var oldCanvasWidth = canvasWidth;

canvasWidth = getCanvasWidth();

if (canvasWidth != oldCanvasWidth) {

$canvas.width(canvasWidth);

$headerRow.width(canvasWidth);

viewportHasHScroll = (canvasWidth > viewportW - scrollbarDimensions.width);

}

if (canvasWidth != oldCanvasWidth || forceColumnWidthsUpdate) {

applyColumnWidths();

}

}

function disableSelection($target) {

if ($target && $target.jquery) {

$target

.attr("unselectable", "on")

.css("MozUserSelect", "none")

.bind("selectstart.ui", function () {

return false;

}); // from jquery:ui.core.js 1.7.2

}

}

function getMaxSupportedCssHeight() {

var increment = 1000000;

var supportedHeight = increment;

// FF reports the height back but still renders blank after ~6M px

var testUpTo = ($.browser.mozilla) ? 5000000 : 1000000000;

var div = $("<div style='display:none' />").appendTo(document.body);

while (supportedHeight <= testUpTo) {

div.css("height", supportedHeight + increment);

if (div.height() !== supportedHeight + increment) {

break;

} else {

supportedHeight += increment;

}

}

div.remove();

return supportedHeight;

}

// TODO: this is static. need to handle page mutation.

function bindAncestorScrollEvents() {

var elem = $canvas[0];

while ((elem = elem.parentNode) != document.body && elem != null) {

// bind to scroll containers only

if (elem == $viewport[0] || elem.scrollWidth != elem.clientWidth || elem.scrollHeight != elem.clientHeight) {

$(elem).bind("scroll.slickgrid", handleActiveCellPositionChange);

}

}

}

function unbindAncestorScrollEvents() {

$canvas.parents().unbind("scroll.slickgrid");

}

function updateColumnHeader(columnId, title, toolTip) {

if (!initialized) { return; }

var idx = getColumnIndex(columnId);

var $header = $headers.children().eq(idx);

if ($header) {

columns[idx].name = title;

columns[idx].toolTip = toolTip;

$header

.attr("title", toolTip || title || "")

.children().eq(0).html(title);

}

}

function getHeaderRow() {

return $headerRow[0];

}

function getHeaderRowColumn(columnId) {

var idx = getColumnIndex(columnId);

var $header = $headerRow.children().eq(idx);

return $header && $header[0];

}

function createColumnHeaders() {

function hoverBegin() {

$(this).addClass("ui-state-hover");

}

function hoverEnd() {

$(this).removeClass("ui-state-hover");

}

$headers.empty();

$headerRow.empty();

columnsById = {};

for (var i = 0; i < columns.length; i++) {

var m = columns[i] = $.extend({}, columnDefaults, columns[i]);

columnsById[m.id] = i;

var header = $("<div class='ui-state-default slick-header-column' id='" + uid + m.id + "' />")

.html("<span class='slick-column-name'>" + m.name + "</span>")

.width(m.width - headerColumnWidthDiff)

.attr("title", m.toolTip || m.name || "")

.data("fieldId", m.id)

.addClass(m.headerCssClass || "")

.appendTo($headers);

if (options.enableColumnReorder || m.sortable) {

header.hover(hoverBegin, hoverEnd);

}

if (m.sortable) {

header.append("<span class='slick-sort-indicator' />");

}

if (options.showHeaderRow) {

$("<div class='ui-state-default slick-headerrow-column l" + i + " r" + i + "'></div>")

.appendTo($headerRow);

}

}

if (options.showHeaderRow) {

// add a spacer to let the container scroll beyond the header row columns width

$("<div style='display:block;height:1px;width:10000px;position:absolute;top:0;left:0;'></div>")

.appendTo($headerRowScroller);

}

setSortColumns(sortColumns);

setupColumnResize();

if (options.enableColumnReorder) {

setupColumnReorder();

}

}

function setupColumnSort() {

$headers.click(function (e) {

// temporary workaround for a bug in jQuery 1.7.1 (http://bugs.jquery.com/ticket/11328)

e.metaKey = e.metaKey || e.ctrlKey;

if ($(e.target).hasClass("slick-resizable-handle")) {

return;

}

var $col = $(e.target).closest(".slick-header-column");

if (!$col.length) {

return;

}

var column = columns[getColumnIndex($col.data("fieldId"))];

if (column.sortable) {

if (!getEditorLock().commitCurrentEdit()) {

return;

}

var sortOpts = null;

var i = 0;

for (; i < sortColumns.length; i++) {

if (sortColumns[i].columnId == column.id) {

sortOpts = sortColumns[i];

sortOpts.sortAsc = !sortOpts.sortAsc;

break;

}

}

if (e.metaKey && options.multiColumnSort) {

if (sortOpts) {

sortColumns.splice(i, 1);

}

}

else {

if ((!e.shiftKey && !e.metaKey) || !options.multiColumnSort) {

sortColumns = [];

}

if (!sortOpts) {

sortOpts = { columnId: column.id, sortAsc: true };

sortColumns.push(sortOpts);

} else if (sortColumns.length == 0) {

sortColumns.push(sortOpts);

}

}

setSortColumns(sortColumns);

if (!options.multiColumnSort) {

trigger(self.onSort, {

multiColumnSort: false,

sortCol: column,

sortAsc: sortOpts.sortAsc}, e);

} else {

trigger(self.onSort, {

multiColumnSort: true,

sortCols: $.map(sortColumns, function(col) {

return {sortCol: columns[getColumnIndex(col.columnId)], sortAsc: col.sortAsc };

})}, e);

}

}

});

}

function setupColumnReorder() {

$headers.sortable({

containment: "parent",

axis: "x",

cursor: "default",

tolerance: "intersection",

helper: "clone",

placeholder: "slick-sortable-placeholder ui-state-default slick-header-column",

forcePlaceholderSize: true,

start: function (e, ui) {

$(ui.helper).addClass("slick-header-column-active");

},

beforeStop: function (e, ui) {

$(ui.helper).removeClass("slick-header-column-active");

},

stop: function (e) {

if (!getEditorLock().commitCurrentEdit()) {

$(this).sortable("cancel");

return;

}

var reorderedIds = $headers.sortable("toArray");

var reorderedColumns = [];

for (var i = 0; i < reorderedIds.length; i++) {

reorderedColumns.push(columns[getColumnIndex(reorderedIds[i].replace(uid, ""))]);

}

setColumns(reorderedColumns);

trigger(self.onColumnsReordered, {});

e.stopPropagation();

setupColumnResize();

}

});

}

function setupColumnResize() {

var $col, j, c, pageX, columnElements, minPageX, maxPageX, firstResizable, lastResizable;

columnElements = $headers.children();

columnElements.find(".slick-resizable-handle").remove();

columnElements.each(function (i, e) {

if (columns[i].resizable) {

if (firstResizable === undefined) {

firstResizable = i;

}

lastResizable = i;

}

});

if (firstResizable === undefined) {

return;

}

columnElements.each(function (i, e) {

if (i < firstResizable || (options.forceFitColumns && i >= lastResizable)) {

return;

}

$col = $(e);

$("<div class='slick-resizable-handle' />")

.appendTo(e)

.bind("dragstart", function (e, dd) {

if (!getEditorLock().commitCurrentEdit()) {

return false;

}

pageX = e.pageX;

$(this).parent().addClass("slick-header-column-active");

var shrinkLeewayOnRight = null, stretchLeewayOnRight = null;

// lock each column's width option to current width

columnElements.each(function (i, e) {

columns[i].previousWidth = $(e).outerWidth();

});

if (options.forceFitColumns) {

shrinkLeewayOnRight = 0;

stretchLeewayOnRight = 0;

// colums on right affect maxPageX/minPageX

for (j = i + 1; j < columnElements.length; j++) {

c = columns[j];

if (c.resizable) {

if (stretchLeewayOnRight !== null) {

if (c.maxWidth) {

stretchLeewayOnRight += c.maxWidth - c.previousWidth;

} else {

stretchLeewayOnRight = null;

}

}

shrinkLeewayOnRight += c.previousWidth - Math.max(c.minWidth || 0, absoluteColumnMinWidth);

}

}

}

var shrinkLeewayOnLeft = 0, stretchLeewayOnLeft = 0;

for (j = 0; j <= i; j++) {

// columns on left only affect minPageX

c = columns[j];

if (c.resizable) {

if (stretchLeewayOnLeft !== null) {

if (c.maxWidth) {

stretchLeewayOnLeft += c.maxWidth - c.previousWidth;

} else {

stretchLeewayOnLeft = null;

}

}

shrinkLeewayOnLeft += c.previousWidth - Math.max(c.minWidth || 0, absoluteColumnMinWidth);

}

}

if (shrinkLeewayOnRight === null) {

shrinkLeewayOnRight = 100000;

}

if (shrinkLeewayOnLeft === null) {

shrinkLeewayOnLeft = 100000;

}

if (stretchLeewayOnRight === null) {

stretchLeewayOnRight = 100000;

}

if (stretchLeewayOnLeft === null) {

stretchLeewayOnLeft = 100000;

}

maxPageX = pageX + Math.min(shrinkLeewayOnRight, stretchLeewayOnLeft);

minPageX = pageX - Math.min(shrinkLeewayOnLeft, stretchLeewayOnRight);

})

.bind("drag", function (e, dd) {

var actualMinWidth, d = Math.min(maxPageX, Math.max(minPageX, e.pageX)) - pageX, x;

if (d < 0) { // shrink column

x = d;

for (j = i; j >= 0; j--) {

c = columns[j];

if (c.resizable) {

actualMinWidth = Math.max(c.minWidth || 0, absoluteColumnMinWidth);

if (x && c.previousWidth + x < actualMinWidth) {

x += c.previousWidth - actualMinWidth;

c.width = actualMinWidth;

} else {

c.width = c.previousWidth + x;

x = 0;

}

}

}

if (options.forceFitColumns) {

x = -d;

for (j = i + 1; j < columnElements.length; j++) {

c = columns[j];

if (c.resizable) {

if (x && c.maxWidth && (c.maxWidth - c.previousWidth < x)) {

x -= c.maxWidth - c.previousWidth;

c.width = c.maxWidth;

} else {

c.width = c.previousWidth + x;

x = 0;

}

}

}

}

} else { // stretch column

x = d;

for (j = i; j >= 0; j--) {

c = columns[j];

if (c.resizable) {

if (x && c.maxWidth && (c.maxWidth - c.previousWidth < x)) {

x -= c.maxWidth - c.previousWidth;

c.width = c.maxWidth;

} else {

c.width = c.previousWidth + x;

x = 0;

}

}

}

if (options.forceFitColumns) {

x = -d;

for (j = i + 1; j < columnElements.length; j++) {

c = columns[j];

if (c.resizable) {

actualMinWidth = Math.max(c.minWidth || 0, absoluteColumnMinWidth);

if (x && c.previousWidth + x < actualMinWidth) {

x += c.previousWidth - actualMinWidth;

c.width = actualMinWidth;

} else {

c.width = c.previousWidth + x;

x = 0;

}

}

}

}

}

applyColumnHeaderWidths();

if (options.syncColumnCellResize) {

applyColumnWidths();

}

})

.bind("dragend", function (e, dd) {

var newWidth;

$(this).parent().removeClass("slick-header-column-active");

for (j = 0; j < columnElements.length; j++) {

c = columns[j];

newWidth = $(columnElements[j]).outerWidth();

if (c.previousWidth !== newWidth && c.rerenderOnResize) {

invalidateAllRows();

}

}

updateCanvasWidth(true);

render();

trigger(self.onColumnsResized, {});

});

});

}

function getVBoxDelta($el) {

var p = ["borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"];

var delta = 0;

$.each(p, function (n, val) {

delta += parseFloat($el.css(val)) || 0;

});

return delta;

}

function measureCellPaddingAndBorder() {

var el;

var h = ["borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight"];

var v = ["borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"];

el = $("<div class='ui-state-default slick-header-column' style='visibility:hidden'>-</div>").appendTo($headers);

headerColumnWidthDiff = headerColumnHeightDiff = 0;

$.each(h, function (n, val) {

headerColumnWidthDiff += parseFloat(el.css(val)) || 0;

});

$.each(v, function (n, val) {

headerColumnHeightDiff += parseFloat(el.css(val)) || 0;

});

el.remove();

var r = $("<div class='slick-row' />").appendTo($canvas);

el = $("<div class='slick-cell' id='' style='visibility:hidden'>-</div>").appendTo(r);

cellWidthDiff = cellHeightDiff = 0;

$.each(h, function (n, val) {

cellWidthDiff += parseFloat(el.css(val)) || 0;

});

$.each(v, function (n, val) {

cellHeightDiff += parseFloat(el.css(val)) || 0;

});

r.remove();

absoluteColumnMinWidth = Math.max(headerColumnWidthDiff, cellWidthDiff);

}

function createCssRules() {

$style = $("<style type='text/css' rel='stylesheet' />").appendTo($("head"));

var rowHeight = (options.rowHeight - cellHeightDiff);

var rules = [

"." + uid + " .slick-header-column { left: 1000px; }",

"." + uid + " .slick-top-panel { height:" + options.topPanelHeight + "px; }",

"." + uid + " .slick-headerrow-columns { height:" + options.headerRowHeight + "px; }",

"." + uid + " .slick-cell { height:" + rowHeight + "px; }",

"." + uid + " .slick-row { height:" + options.rowHeight + "px; }"

];

for (var i = 0; i < columns.length; i++) {

rules.push("." + uid + " .l" + i + " { }");

rules.push("." + uid + " .r" + i + " { }");

}

if ($style[0].styleSheet) { // IE

$style[0].styleSheet.cssText = rules.join(" ");

} else {

$style[0].appendChild(document.createTextNode(rules.join(" ")));

}

}

function getColumnCssRules(idx) {

if (!stylesheet) {

var sheets = document.styleSheets;

for (var i = 0; i < sheets.length; i++) {

if ((sheets[i].ownerNode || sheets[i].owningElement) == $style[0]) {

stylesheet = sheets[i];

break;

}

}

if (!stylesheet) {

throw new Error("Cannot find stylesheet.");

}

// find and cache column CSS rules

columnCssRulesL = [];

columnCssRulesR = [];

var cssRules = (stylesheet.cssRules || stylesheet.rules);

var matches, columnIdx;

for (var i = 0; i < cssRules.length; i++) {

var selector = cssRules[i].selectorText;

if (matches = /\.l\d+/.exec(selector)) {

columnIdx = parseInt(matches[0].substr(2, matches[0].length - 2), 10);

columnCssRulesL[columnIdx] = cssRules[i];

} else if (matches = /\.r\d+/.exec(selector)) {

columnIdx = parseInt(matches[0].substr(2, matches[0].length - 2), 10);

columnCssRulesR[columnIdx] = cssRules[i];

}

}

}

return {

"left": columnCssRulesL[idx],

"right": columnCssRulesR[idx]

};

}

function removeCssRules() {

$style.remove();

stylesheet = null;

}

function destroy() {

getEditorLock().cancelCurrentEdit();

trigger(self.onBeforeDestroy, {});

for (var i = 0; i < plugins.length; i++) {

unregisterPlugin(plugins[i]);

}

if (options.enableColumnReorder && $headers.sortable) {

$headers.sortable("destroy");

}

unbindAncestorScrollEvents();

$container.unbind(".slickgrid");

removeCssRules();

$canvas.unbind("draginit dragstart dragend drag");

$container.empty().removeClass(uid);

}

//////////////////////////////////////////////////////////////////////////////////////////////

// General

function trigger(evt, args, e) {

e = e || new Slick.EventData();

args = args || {};

args.grid = self;

return evt.notify(args, e, self);

}

function getEditorLock() {

return options.editorLock;

}

function getEditController() {

return editController;

}

function getColumnIndex(id) {

return columnsById[id];

}

function autosizeColumns() {

var i, c,

widths = [],

shrinkLeeway = 0,

total = 0,

prevTotal,

availWidth = viewportHasVScroll ? viewportW - scrollbarDimensions.width : viewportW;

for (i = 0; i < columns.length; i++) {

c = columns[i];

widths.push(c.width);

total += c.width;

if (c.resizable) {

shrinkLeeway += c.width - Math.max(c.minWidth, absoluteColumnMinWidth);

}

}

// shrink

prevTotal = total;

while (total > availWidth && shrinkLeeway) {

var shrinkProportion = (total - availWidth) / shrinkLeeway;

for (i = 0; i < columns.length && total > availWidth; i++) {

c = columns[i];

var width = widths[i];

if (!c.resizable || width <= c.minWidth || width <= absoluteColumnMinWidth) {

continue;

}

var absMinWidth = Math.max(c.minWidth, absoluteColumnMinWidth);

var shrinkSize = Math.floor(shrinkProportion * (width - absMinWidth)) || 1;

shrinkSize = Math.min(shrinkSize, width - absMinWidth);

total -= shrinkSize;

shrinkLeeway -= shrinkSize;

widths[i] -= shrinkSize;

}

if (prevTotal == total) { // avoid infinite loop

break;

}

prevTotal = total;

}

// grow

prevTotal = total;

while (total < availWidth) {

var growProportion = availWidth / total;

for (i = 0; i < columns.length && total < availWidth; i++) {

c = columns[i];

if (!c.resizable || c.maxWidth <= c.width) {

continue;

}

var growSize = Math.min(Math.floor(growProportion * c.width) - c.width, (c.maxWidth - c.width) || 1000000) || 1;

total += growSize;

widths[i] += growSize;

}

if (prevTotal == total) { // avoid infinite loop

break;

}

prevTotal = total;

}

var reRender = false;

for (i = 0; i < columns.length; i++) {

if (columns[i].rerenderOnResize && columns[i].width != widths[i]) {

reRender = true;

}

columns[i].width = widths[i];

}

applyColumnHeaderWidths();

updateCanvasWidth(true);

if (reRender) {

invalidateAllRows();

render();

}

}

function applyColumnHeaderWidths() {

if (!initialized) { return; }

var h;

for (var i = 0, headers = $headers.children(), ii = headers.length; i < ii; i++) {

h = $(headers[i]);

if (h.width() !== columns[i].width - headerColumnWidthDiff) {

h.width(columns[i].width - headerColumnWidthDiff);

}

}

}

function applyColumnWidths() {

var x = 0, w, rule;

for (var i = 0; i < columns.length; i++) {

w = columns[i].width;

rule = getColumnCssRules(i);

rule.left.style.left = x + "px";

rule.right.style.right = (canvasWidth - x - w) + "px";