@refinitiv-ui/efx-grid 6.0.0-next.0

package/lib/core/es6/grid/util/TrackLayout.js

@@ -0,0 +1,850 @@
+import Util from "../util/util.js";
+
+/** TrackLayout is like a running track in a football field which contains multiple lanes.
+* TrackLayout defines position and size for all its lanes, as well as support binarySearch for hit testing
+* @constructor
+* @ignore
+*/
+var TrackLayout = function () {
+	this._ends = [];
+	this._cols = [];
+};
+
+/** @type {number}
+* @private
+*/
+TrackLayout.prototype._laneCount = 0;
+/** @type {number}
+* @private
+*/
+TrackLayout.prototype._defaultSize = 10;
+/** @type {boolean}
+* @private
+*/
+TrackLayout.prototype._defaultScalability = true;
+/** @type {boolean}
+* @private
+*/
+TrackLayout.prototype._homogeneous = true;
+/** @type {boolean}
+* @private
+*/
+TrackLayout.prototype._visibility = true;
+/** Cumulative end position of each lane
+* @type {!Array.<number>}
+* @private
+*/
+TrackLayout.prototype._ends;
+/** @type {!Array.<Object>}
+* @private
+*/
+TrackLayout.prototype._cols;
+
+/** @type {!Array.<number>}
+* @private
+*/
+TrackLayout.prototype._bits = [1, 2, 4, 8]; // Static variable
+
+
+
+/** If track size is 50 and start from 0, [0, 49] counts as a hit, while 50 does not
+* @public
+* @param {number} val
+* @return {number} Positive index if hit, otherwise negative
+*/
+TrackLayout.prototype.hitTest = function (val) {
+	if (val < 0) { return -1; }
+
+	// getTrackSize has updated the cache for usage. Do not call this._updateEndPoints()
+	var totalSize = this.getTrackSize();
+	if (val >= totalSize) { return ~this._laneCount; } // totalSize does not count as a hit
+
+	var hitIndex = -1;
+	var validRange = 0;
+	if (this._homogeneous) { // Each row has the same size
+		var laneSize = this._defaultSize;
+		hitIndex = Math.floor(val / laneSize);
+		validRange = ((hitIndex + 1) * laneSize);
+	} else {
+		hitIndex = Util.upperBound(this._ends, val);
+		validRange = this._ends[hitIndex];
+	}
+
+	if (hitIndex >= this._laneCount || val >= validRange) {
+		hitIndex = ~hitIndex; // invert to negative value
+	}
+	return hitIndex;
+};
+
+/** If optional index is not given, the entire track is taken into account
+* @public
+* @param {number=} opt_index
+* @return {boolean}
+*/
+TrackLayout.prototype.isAtDefaultSize = function (opt_index) {
+	if(this._homogeneous) {
+		return true; // All lanes are at the default size
+	}
+	if (opt_index != null) {
+		if(!this._isAtDefaultSize(opt_index)) {
+			return false;
+		}
+	} else {
+		for (var i = this._cols.length; --i >= 0; ) {
+			if (!this._isAtDefaultSize(i)) {
+				return false;
+			}
+		}
+		this._homogeneous = true; // All lane are at the default size
+	}
+	return true;
+};
+/** @private
+* @param {number} index
+* @return {boolean}
+*/
+TrackLayout.prototype._isAtDefaultSize = function (index) {
+	var col = this._cols[index];
+	if (col) {
+		if (col.actualSize !== this._defaultSize) {
+			return false;
+		}
+		if (col.customSize != null) {
+			return false;
+		}
+		if(col.invisibility) {
+			return false;
+		}
+	}
+	return true;
+};
+/** @public
+* @return {boolean}
+*/
+TrackLayout.prototype.isHomogeneous = function () {
+	return this._homogeneous;
+};
+
+/** If optional index is not given, the entire track is taken into account
+* @public
+* @param {number=} opt_index
+* @return {boolean}
+*/
+TrackLayout.prototype.isAtMinimumSize = function (opt_index) {
+	var minSize = this._getMinimumScalingSize(opt_index);
+	var trackSize = (opt_index != null) ? this.getLaneSize(opt_index) : this.getTrackSize();
+	return trackSize <= minSize;
+};
+
+/** Track is fixed size if all lane are not scalable
+* @public
+* @return {boolean}
+*/
+TrackLayout.prototype.isFixedSize = function () {
+	for (var i = 0; i < this._laneCount; ++i) {
+		if (this.getLaneScalability(i)) {
+			return false;
+		}
+	}
+	return true;
+};
+
+/** Clear all customizations of all lanes including visibility, custom size, minimum size, and scalability
+* @public
+*/
+TrackLayout.prototype.clearLaneCustomizations = function () {
+	this._ends.length = 0;
+	this._cols.length = 0;
+	this._homogeneous = true;
+};
+
+/** @public
+* @return {number}
+*/
+TrackLayout.prototype.getLaneCount = function () {
+	return this._laneCount;
+};
+/** @public
+* @param {number} val
+*/
+TrackLayout.prototype.setLaneCount = function (val) {
+	if (val < 0) { val = 0; }
+	if (val === this._laneCount) { return; }
+
+	this._markDirtyIndex(val);
+	this._cols.length = val;
+	this._laneCount = val;
+	if (val === 0) { this._homogeneous = true; }
+};
+/**
+* @public
+* @return {number}
+*/
+TrackLayout.prototype.getDefaultLaneSize = function () {
+	return this._defaultSize;
+};
+/** @public
+* @param {number} val
+* @return {boolean}
+*/
+TrackLayout.prototype.setDefaultLaneSize = function (val) {
+	if (val < 0) { val = 0; }
+	if (this._defaultSize !== val) {
+		this._defaultSize = val;
+		this._markDirtyIndex(0);
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {number} index
+* @return {number}
+*/
+TrackLayout.prototype.getLaneDefaultSize = function (index) {
+	if (index < 0 || index >= this._laneCount) { return -1; }
+	var col = this._newColumn(index);
+	if(col.defaultSize) {
+		return col.defaultSize;
+	} else {
+		return -1;
+	}
+};
+/** @public
+* @param {number} index
+* @param {number} val
+*/
+TrackLayout.prototype.setLaneDefaultSize = function (index, val) {
+	if (index < 0 || index >= this._laneCount) { return; }
+	if (val >= 0) {
+		var col = this._newColumn(index);
+		col.defaultSize = val;
+	}
+};
+/** @public
+* @return {boolean}
+*/
+TrackLayout.prototype.resetLaneToDefaultSize = function () {
+	var dirty = false;
+	for (var i = 0; i < this._laneCount; ++i) {
+		var col = this._cols[i];
+		if (col) {
+			if (!col.invisibility) {
+				if (col.defaultSize != null) {
+					dirty |= this.setLaneScalability(i, false);
+					dirty |= this.setLaneSize(i, col.defaultSize);
+				} else {
+					dirty |= this.setLaneScalability(i, true);
+					dirty |= this.setLaneSize(i, 1);
+				}
+			}
+		}
+	}
+	return dirty ? true : false;
+};
+/**
+* @public
+* @return {boolean}
+*/
+TrackLayout.prototype.getDefaultScalability = function () {
+	return this._defaultScalability;
+};
+/** @public
+* @param {boolean} val
+* @return {boolean}
+*/
+TrackLayout.prototype.setDefaultScalability = function (val) {
+	if (this._defaultScalability !== val) {
+		this._defaultScalability = val;
+		// this._markDirtyIndex(0); WARNING: Scalability does not have any impact on lane size
+		return true;
+	}
+	return false;
+};
+
+
+/** @public
+* @return {number}
+*/
+TrackLayout.prototype.getTrackSize = function () {
+	if (!this._visibility || this._laneCount <= 0) { return 0; }
+
+	if (this._homogeneous) {
+		return this._laneCount * this._defaultSize;
+	}
+
+	this._updateEndPoints();
+	return this._ends[this._laneCount - 1]; // Return the end of the last item
+};
+/** Scale all lanes based on the given available space. Only the specified flexible lanes are adjusted.
+* If all lanes are eqaul in size (even zero size), they all will be weighted equally
+* @public
+* @param {number} targetSize
+* @param {number} reserveSpace
+* @return {Array.<number>|null} Array of size adjustment. Return null if there is no change
+*/
+TrackLayout.prototype.setTrackSize = function (targetSize, reserveSpace) {
+	var i = 0, fixedSize = 0;
+	var indices = [];
+	// Collecting current data for calculation
+	for (i = 0; i < this._laneCount; ++i) {
+		var col = this._cols[i];
+		if (col) {
+			if (!col.invisibility) { // If column is visible
+				if (this._getLaneScalability(col) !== false) {
+					indices.push(i);
+				} else {
+					fixedSize += this._getFixedSize(col);
+				}
+			}
+		} else {
+			indices.push(i);
+		}
+	}
+	if (indices.length <= 0) { return null; }
+
+	var distributions = this._distributeLaneSize(targetSize - fixedSize - reserveSpace, indices);
+
+	// Find any change to flexible lane size
+	var dirty = false;
+	var changes = [];
+	for (i = distributions.length; --i >= 0; ) {
+		changes[i] = 0;
+		var val = distributions[i];
+		if (val != null) {
+			var cal = this.getLaneSize(i);
+			this._newColumn(i);
+			if (this._setCalculatedLaneSize(i, val)) {
+				changes[i] = val - cal;
+				dirty = true;
+			}
+		}
+	}
+	return (dirty) ? changes : null;
+};
+
+/** This method is forgiving and often used for size predictions. Thus, out of bounds index is accepted
+* Negative index will be treated as 0. Any exceeding lane will be treated to have a default size
+* @public
+* @param {number} index
+* @return {number}
+*/
+TrackLayout.prototype.getLaneStart = function (index) {
+	if (index <= 0) return 0;
+
+	if (this._homogeneous) {
+		return index * this._defaultSize;
+	}
+
+	this._updateEndPoints();
+	var exceedings = index - this._laneCount;
+	var exceededPortion = 0;
+	if (exceedings > 0) {
+		index -= exceedings;
+		exceededPortion = exceedings * this._defaultSize;
+	}
+	// Return the end point of the previous item
+	return this._ends[index - 1] + exceededPortion;
+};
+/** Any invalid index will be automatically adjusted to be in a valid range.
+* @public
+* @param {number} index
+* @return {number} if there is no lane, NaN value is returned
+*/
+TrackLayout.prototype.getLaneEnd = function (index) {
+	if (this._laneCount <= 0) { return NaN; }
+	if (index < 0) { index = 0; }
+	else if (index >= this._laneCount) { index = this._laneCount - 1; }
+
+	if (this._homogeneous) {
+		return (index + 1) * this._defaultSize;
+	}
+
+	this._updateEndPoints();
+
+	return this._ends[index]; // Return the end point of the previous item
+};
+
+/** @public
+* @param {number} index
+* @return {number}
+*/
+TrackLayout.prototype.getLaneSize = function (index) {
+	if (this._visibility) {
+		var col = this._cols[index];
+		return (col) ? col.actualSize : this._defaultSize;
+	}
+	return 0;
+};
+/** @public
+* @param {number} index
+* @return {number}
+*/
+TrackLayout.prototype.getCustomLaneSize = function (index) {
+	var col = this._cols[index];
+	return (col && col.customSize != null) ? col.customSize : this._defaultSize;
+};
+/** @public
+* @param {number} index
+* @param {number} val
+* @return {boolean}
+*/
+TrackLayout.prototype.setLaneSize = function (index, val) {
+	if (index < 0 || index >= this._laneCount) { return false; }
+	if (val < 0 || val !== val) { return false; }
+
+	var col = this._cols[index];
+	if (col == null || col.customSize !== val) {
+		col = this._newColumn(index);
+		col.customSize = val;
+		return this._setCalculatedLaneSize(index, val);
+	}
+
+	return false;
+};
+
+/** @public
+* @param {number} index
+* @return {number}
+*/
+TrackLayout.prototype.getMinimumLaneSize = function (index) {
+	var col = this._cols[index];
+	return (col && col.minSize != null) ? col.minSize : 0;
+};
+/** Minimum lane size governs custom lane size in calculation
+* @public
+* @param {number} index
+* @param {number} val
+* @param {boolean=} proportion This will make the lane expand in proportion of its min width when there is enough space.
+* @return {boolean} Return true if there is a change in the custom lane size, false otherwise
+*/
+TrackLayout.prototype.setMinimumLaneSize = function (index, val, proportion) {
+	if (index < 0 || index >= this._laneCount) { return false; }
+	if (val < 0) { val = 0; }
+	if (this.getMinimumLaneSize(index) !== val) {
+		var col = this._newColumn(index);
+		col.minSize = val;
+
+		if(proportion) {
+			if (this.getLaneScalability(index)) {
+				col.customSize = val;
+			}
+		}
+		return this._setCalculatedLaneSize(index);
+	}
+	return false;
+};
+/** @public
+* @param {number} index
+* @return {boolean}
+*/
+TrackLayout.prototype.isLaneVisible = function (index) {
+	var col = this._cols[index];
+	return col ? !col.invisibility : true;
+};
+/** @public
+* @param {number} index
+* @param {boolean=} opt_val
+* @return {boolean}
+*/
+TrackLayout.prototype.showLane = function (index, opt_val) {
+	return this.hideLane(index, opt_val === false);
+};
+/** @public
+* @param {number} index
+* @param {boolean=} opt_hidden
+* @param {number=} opt_bitIndex
+* @return {boolean}
+*/
+TrackLayout.prototype.hideLane = function (index, opt_hidden, opt_bitIndex) {
+	if (index < 0 || index >= this._laneCount) { return false; }
+
+	var col = this._newColumn(index);
+	var prevVis = !col.invisibility;
+
+	var bit = (opt_bitIndex != null) ? this._bits[opt_bitIndex] : 1;
+	if(opt_hidden !== false) {
+		col.invisibility |= bit; // Add invisibility bit
+	} else {
+		col.invisibility &= ~bit; // Remove invisibility bit
+	}
+
+	if (prevVis !== (!col.invisibility)) {
+		return this._setCalculatedLaneSize(index);
+	}
+	return false;
+};
+/** @public
+* @param {boolean=} opt_shown
+*/
+TrackLayout.prototype.show = function (opt_shown) {
+	opt_shown = opt_shown !== false;
+	if (this._visibility !== opt_shown) {
+		this._visibility = opt_shown;
+		if (opt_shown) {
+			for (var i = 0; i < this._laneCount; ++i) {
+				this._newColumn(i);
+				this._setCalculatedLaneSize(i);
+			}
+		} else {
+			this._markDirtyIndex(0);
+		}
+	}
+};
+
+/** @public
+* @param {number} index
+* @return {boolean}
+*/
+TrackLayout.prototype.getLaneScalability = function (index) {
+	var col = this._cols[index];
+	return (col && col.scalability != null) ? col.scalability : this._defaultScalability;
+};
+/** @public
+* @param {number} index
+* @param {boolean} val
+* @return {boolean}
+*/
+TrackLayout.prototype.setLaneScalability = function (index, val) {
+	if (index < 0 || index >= this._laneCount) { return false; }
+
+	var col = this._cols[index];
+	if (!col || col.scalability !== val) {
+		col = this._newColumn(index);
+		col.scalability = val;
+		return true;
+	}
+	return false;
+};
+
+/** @public
+* @param {number} index
+* @param {number=} opt_count Default is 1
+* @return {Object|null}
+*/
+TrackLayout.prototype.removeLaneAt = function (index, opt_count) {
+	if(opt_count == null) { opt_count = 1; }
+	if(index < 0) { return null; }
+	if(index + opt_count > this._laneCount) {
+		opt_count = this._laneCount - index;
+	}
+	if(opt_count < 1) { // Nothing to be removed
+		return null;
+	}
+
+	this._markDirtyIndex(index);
+	var userSettings = this.serializeLane(index); // TODO: This is unnecessary
+	this._cols.splice(index, opt_count);
+
+	this._laneCount -= opt_count;
+	return userSettings;
+};
+/** @public
+* @param {number} index
+* @param {number|Object=} opt_json Numeric value means number of lane to be inserted, while object value means the settings of the lane
+*/
+TrackLayout.prototype.insertLane = function (index, opt_json) {
+	if (index < 0) { index = 0; }
+	var chunkSize = 1;
+	if (Util.isNumber(opt_json)) {
+		if (/** @type{number} */(opt_json) <= 0) { return; }
+		chunkSize = /** @type{number} */(opt_json);
+		opt_json = null;
+	}
+
+	if (index >= this._laneCount) {
+		index = this._laneCount;
+		if (!opt_json) { // No special setting
+			this.setLaneCount(this._laneCount + chunkSize);
+			return;
+		}
+	}
+
+	this._laneCount += chunkSize;
+	this._markDirtyIndex(index); // Only mark at the lowest index
+
+	Util.insertEmptyItems(this._cols, index, chunkSize);
+	if (opt_json) {
+		var toIndex = index + chunkSize;
+		for (var i = index; i < toIndex; ++i) {
+			this.deserializeLane(i, /** @type{Object} */(opt_json));
+		}
+	}
+};
+/** @public
+* @param {number} from
+* @param {number} to
+*/
+TrackLayout.prototype.moveLane = function (from, to) {
+	if (from < 0) { from = 0; }
+	else if (from > this._laneCount) { from = this._laneCount; }
+	if (to < 0) { to = 0; }
+	else if (to > this._laneCount) { to = this._laneCount; }
+	if (from === to) { return; }
+
+	var minIndex = (from < to) ? from : to;
+	this._markDirtyIndex(minIndex);
+
+	Util.moveArrayItem(this._cols, from, to);
+};
+
+/** @public
+* @param {number} index
+* @return {Object|null}
+*/
+TrackLayout.prototype.serializeLane = function (index) {
+	if (index < 0 || index >= this._laneCount) { return null; }
+
+	var userSettings = {};
+	userSettings["index"] = index;
+
+	var col = this._cols[index];
+	if (!col) { return userSettings; }
+
+	userSettings["size"] = col.customSize;
+	userSettings["minSize"] = col.minSize;
+	userSettings["visible"] = !col.invisibility;
+	userSettings["scalable"] = col.scalability;
+
+	return userSettings;
+};
+/** @public
+* @param {number} index
+* @param {Object=} opt_json
+*/
+TrackLayout.prototype.deserializeLane = function (index, opt_json) {
+	if (!opt_json) { return; }
+	if (index < 0 || index >= this._laneCount) { return; }
+
+	var val = opt_json["size"];
+	if (val != null) {
+		this.setLaneSize(index, /** @type{number} */(val));
+	}
+	val = opt_json["minSize"];
+	if (val != null) {
+		this.setMinimumLaneSize(index, /** @type{number} */(val));
+	}
+	val = opt_json["visible"];
+	if (val != null) {
+		this.showLane(index, /** @type{boolean} */(val));
+	}
+	val = opt_json["scalable"];
+	if (val != null) {
+		this.setLaneScalability(index, /** @type{boolean} */(val));
+	}
+};
+
+/** @private
+*/
+TrackLayout.prototype._updateEndPoints = function () {
+	var dirtyIndex = this._ends.length;
+	if (dirtyIndex >= this._laneCount) return;
+
+	this._ends.length = this._laneCount;
+
+	var i = 0;
+	var sum = (dirtyIndex > 0) ? this._ends[dirtyIndex - 1] : 0;
+
+	for (i = dirtyIndex; i < this._laneCount; ++i) {
+		sum += this.getLaneSize(i);
+		this._ends[i] = sum;
+	}
+};
+
+/** Calculated size is the result from processing custom size, min size, and visibility
+* @private
+* @param {number} index
+* @param {number=} opt_val
+* @return {boolean}
+*/
+TrackLayout.prototype._setCalculatedLaneSize = function (index, opt_val) {
+	var col = this._cols[index];
+	if (this._visibility && !col.invisibility) { // If column is visible
+		if (opt_val == null) {
+			opt_val = (col.customSize != null) ? col.customSize : this._defaultSize;
+		}
+		if(!col.scalability) { // minSize doesn't applied when lane scalability
+			var minSize = (col.minSize != null) ? col.minSize : 0;
+			if (opt_val < minSize) {
+				opt_val = minSize;
+			}
+		}
+	} else {
+		opt_val = 0;
+	}
+
+	if (col.actualSize !== opt_val) { // actualSize can be undefined value
+		col.actualSize = opt_val;
+		this._homogeneous = false;
+		this._markDirtyIndex(index);
+		return true;
+	}
+
+	return false;
+};
+
+/** @private
+* @param {number=} opt_index
+* @return {number}
+*/
+TrackLayout.prototype._getMinimumScalingSize = function (opt_index) {
+	var sum = 0;
+	if (opt_index != null) {
+		var col = this._cols[opt_index];
+		if (!col.invisibility) {
+			if (col.minSize != null) {
+				if (this._getLaneScalability(col) === false && col.customSize != null) {
+					if (col.customSize > col.minSize) {
+						return col.customSize;
+					}
+				}
+				return col.minSize;
+			}
+		}
+	} else {
+		for (var i = this._laneCount; --i >= 0; ) {
+			sum += this._getMinimumScalingSize(i);
+		}
+	}
+	return sum;
+};
+/** @private
+* @param {Object} col
+* @return {number}
+*/
+TrackLayout.prototype._getFixedSize = function (col) {
+	if(col.customSize != null) {
+		if(col.minSize != null) {
+			return (col.customSize > col.minSize) ? col.customSize : col.minSize;
+		}
+		return col.customSize;
+	} else if(col.minSize != null) {
+		return col.minSize;
+	}
+	return this._defaultSize;
+};
+/** @private
+* @param {Object} col
+* @return {boolean}
+*/
+TrackLayout.prototype._getLaneScalability = function (col) {
+	if (col.scalability == null) { return this._defaultScalability; }
+	return /** @type{boolean} */(col.scalability);
+};
+
+/** Distribute available space to every lane if have enough space. If not enough, priority goes to lane with minimum size.
+* @private
+* @param {number} availSpace
+* @param {Array.<number>} indices
+* @return {!Array.<number>} distributions
+*/
+TrackLayout.prototype._distributeLaneSize = function (availSpace, indices) {
+	if (indices.length <= 0) { return []; }
+	if (availSpace < 0) { availSpace = 0; }
+
+	var i = 0, totalWeight = 0, index = 0, expectedSize = 0;
+	var minSizes = [], laneSizes = [], distributions = [];
+
+	for (i = indices.length; --i >= 0; ) {
+		index = indices[i];
+		minSizes[index] =  this.getMinimumLaneSize(index); // Cache for multiple usage
+		laneSizes[index] = this.getCustomLaneSize(index); // Cache for multiple usage
+		totalWeight += laneSizes[index];
+	}
+
+	var undistributable = true;
+	while(undistributable) { // All lane sizes must at least equal to its minimum width
+		undistributable = false;
+		for (i = indices.length; --i >= 0; ) {
+			index = indices[i];
+			var minSize = minSizes[index];
+			var laneSize = laneSizes[index];
+			expectedSize = availSpace * laneSize / totalWeight;
+			if (expectedSize <= minSize) {
+				undistributable = true;
+				distributions[index] = minSize;
+				availSpace -= minSize;
+				totalWeight -= laneSize;
+				indices.splice(i, 1);
+			}
+		}
+	}
+
+	var lastIndex = indices.length - 1;
+	var occupiedSpace = 0;
+	var fraction = 0;
+	for (i = lastIndex; --i >= 0; ) {
+		index = indices[i];
+		expectedSize = availSpace * laneSizes[index] / totalWeight;
+		var integerSize = Math.floor(expectedSize);
+		fraction += (expectedSize - integerSize);
+		if(fraction >= 1) {
+			++integerSize;
+			--fraction;
+		}
+		distributions[index] = integerSize;
+		occupiedSpace += integerSize;
+	}
+	distributions[indices[lastIndex]] = Math.floor(availSpace - occupiedSpace);
+	return distributions;
+};
+
+/** @private
+* @param {number} index
+*/
+TrackLayout.prototype._markDirtyIndex = function (index) {
+	if (index < this._ends.length) {
+		this._ends.length = index;
+	}
+};
+/** @private
+* @param {number} index
+* @return {!Object}
+*/
+TrackLayout.prototype._newColumn = function (index) {
+	var col = this._cols[index];
+	if (!col) {
+		this._cols[index] = col = {};
+		// Each bit represents visibility state as the followings:
+		// Bit 0 is used for normal show/hide method
+		// Bit 1 is used for expanded/collapsed state of columm grouping
+		// Bit 2 is used for stacking state of column stacking
+		col.invisibility = 0; // Column is visible by default
+	}
+	return col;
+};
+
+/** @public
+* @param {TrackLayout} src
+* @param {number=} offset
+*/
+TrackLayout.prototype.copyFrom = function (src, offset) {
+	if(this._homogeneous && src._homogeneous) {
+		if(this._defaultSize === src._defaultSize) {
+			return;
+		}
+	}
+	if(!offset) { offset = 0; }
+
+	var srcCount = src.getLaneCount();
+	var curCount = this.getLaneCount();
+	var limit = offset + srcCount;
+	if(limit > curCount) {
+		limit = curCount;
+	}
+	var srcIndex = 0;
+	for(var i = offset; i < limit; ++i) {
+		var val = src.getLaneSize(srcIndex++);
+		var col = this._newColumn(i);
+		if (col.customSize !== val) {
+			col.customSize = val;
+			if(col.actualSize !== val) { // WARNING: This does not obey visibility and minSize
+				col.actualSize = val;
+				this._homogeneous = false; // TODO: Improve this flag
+				this._markDirtyIndex(i);
+			}
+		}
+	}
+};
+
+export default TrackLayout;
+export { TrackLayout };