CellSelection.js

define([
	'dojo/_base/declare',
	'dojo/aspect',
	'dojo/dom-class',
	'dojo/on',
	'dojo/has',
	'./Selection'
], function (declare, aspect, domClass, listen, has, Selection) {

	return declare(Selection, {
		// summary:
		//		Add cell level selection capabilities to a grid. The grid will have a selection property and
		//		fire "dgrid-select" and "dgrid-deselect" events.

		// ensure we don't select when an individual cell is not identifiable
		selectionDelegate: '.dgrid-cell',

		_selectionTargetType: 'cells',

		_select: function (cell, toCell, value) {
			var i,
				id;
			if (typeof value === 'undefined') {
				// default to true
				value = true;
			}
			if (typeof cell !== 'object' || !('element' in cell)) {
				cell = this.cell(cell);
			}
			else if (!cell.row) {
				// Row object was passed instead of cell
				if (value && typeof value === 'object') {
					// value is a hash of true/false values
					for (id in value) {
						this._select(this.cell(cell.id, id), null, value[id]);
					}
				}
				else {
					// Select/deselect all columns in row
					for (id in this.columns) {
						this._select(this.cell(cell.id, id), null, value);
					}
				}
				return;
			}
			if (this.allowSelect(cell)) {
				var selection = this.selection,
					rowId = cell.row.id,
					previousRow = selection[rowId];
				if (!cell.column) {
					for (i in this.columns) {
						this._select(this.cell(rowId, i), null, value);
					}
					return;
				}
				var previous = previousRow && previousRow[cell.column.id];
				if (value === null) {
					// indicates a toggle
					value = !previous;
				}
				var element = cell.element;
				previousRow = previousRow || {};
				previousRow[cell.column.id] = value;
				this.selection[rowId] = previousRow;

				// Check for all-false objects to see if it can be deleted.
				// This prevents build-up of unnecessary iterations later.
				var hasSelected = false;
				for (i in previousRow) {
					if (previousRow[i] === true) {
						hasSelected = true;
						break;
					}
				}
				if (!hasSelected) {
					delete this.selection[rowId];
				}

				if (element) {
					// add or remove classes as appropriate
					if (value) {
						domClass.add(element, 'dgrid-selected' +
							(this.addUiClasses ? ' ui-state-active' : ''));
					}
					else {
						domClass.remove(element, 'dgrid-selected ui-state-active');
					}
				}
				/* jshint eqeqeq: false */
				// This comparison could coerce if previous is undefined; TODO: rewrite
				if (value != previous && element) {
					this._selectionEventQueues[(value ? '' : 'de') + 'select'].push(cell);
				}
				if (toCell) {
					if (!toCell.element) {
						toCell = this.cell(toCell);
					}

					if (!toCell || !toCell.row) {
						this._lastSelected = element;
						console.warn('The selection range has been reset because the ' +
							'beginning of the selection is no longer in the DOM. ' +
							'If you are using OnDemandList, you may wish to increase ' +
							'farOffRemoval to avoid this, but note that keeping more nodes ' +
							'in the DOM may impact performance.');
						return;
					}

					var toElement = toCell.element;
					var fromElement = cell.element;
					// Find if it is earlier or later in the DOM
					var direction = this._determineSelectionDirection(fromElement, toElement);
					if (!direction) {
						// The original element was actually replaced
						toCell = this.cell(
							document.getElementById(toCell.row.element.id), toElement.columnId);
						toElement = toCell && toCell.element;
						direction = this._determineSelectionDirection(fromElement, toElement);
					}
					// now we determine which columns are in the range
					var idFrom = cell.column.id,
						idTo = toCell.column.id,
						started,
						columnIds = [];

					for (id in this.columns) {
						if (started) {
							columnIds.push(id);
						}
						if (id === idFrom && (idFrom = columnIds) ||
								id === idTo && (idTo = columnIds)) {
							// Once found, mark it off so we don't hit it again
							columnIds.push(id);
							if (started || (idFrom == columnIds && id == idTo)) {
								// We are done if we hit the last ID, or if the IDs are the same
								break;
							}
							started = true;
						}
					}
					// now we iterate over rows
					var row = cell.row,
						nextNode = row.element;
					toElement = toCell.row.element;
					do {
						// looping through each row..
						// and now loop through each column to be selected
						for (i = 0; i < columnIds.length; i++) {
							cell = this.cell(nextNode, columnIds[i]);
							this._select(cell, null, value);
						}
						if (nextNode == toElement) {
							break;
						}
					} while ((nextNode = cell.row.element[direction]));
				}
			}
		},

		_determineSelectionDirection: function () {
			// Extend Selection to return next/previousSibling instead of down/up,
			// given how CellSelection#_select is written
			var result = this.inherited(arguments);
			if (result === 'down') {
				return 'nextSibling';
			}
			if (result === 'up') {
				return 'previousSibling';
			}
			return result;
		},

		isSelected: function (object, columnId) {
			// summary:
			//		Returns true if the indicated cell is selected.

			if (typeof object === 'undefined' || object === null) {
				return false;
			}
			if (!object.element) {
				object = this.cell(object, columnId);
			}

			// First check whether the given cell is indicated in the selection hash;
			// failing that, check if allSelected is true (testing against the
			// allowSelect method if possible)
			var rowId = object.row.id;
			if (rowId in this.selection) {
				return !!this.selection[rowId][object.column.id];
			}
			else {
				return this.allSelected && (!object.row.data || this.allowSelect(object));
			}
		},
		clearSelection: function (exceptId) {
			// disable exceptId in cell selection, since it would require double parameters
			exceptId = false;
			this.inherited(arguments);
		}
	});
});