analytics/webcontent/dojo17/dojox/dnd/Selector.js

define("dojox/dnd/Selector", ["dojo", "dojox", "dojo/dnd/Selector"], function(dojo, dojox) {

	return dojo.declare('dojox.dnd.Selector', dojo.dnd.Selector, {

			conservative: true,
			
			isSelected: function(node) {
				//	summary:
				//		checks if node is selected
				//	node: String|DomNode:
				//		Node to check (id or DOM Node)
				var id = dojo.isString(node) ? node : node.id,
					item = this.getItem(id);
				return item && this.selected[id];	// Boolean
			},

			selectNode: function(node, add) {
				//	summary:
				//		selects a node
				//	node: String|DomNode:
				//		Node to select (id or DOM Node)
				//	add: Boolean?:
				//		If true, node is added to selection, otherwise current
				//		selection is removed, and node will be the only selection.
				if (!add) {
					this.selectNone();
				}
				var id = dojo.isString(node) ? node : node.id,
					item = this.getItem(id);
				if (item) {
					this._removeAnchor();
					this.anchor = dojo.byId(node);
					this._addItemClass(this.anchor, 'Anchor');
					this.selection[id] = 1;
					this._addItemClass(this.anchor, 'Selected');
				}
				return this;	// self
			},

			deselectNode: function(node) {
				//	summary:
				//		deselects a node
				//	node: String|DomNode:
				//		Node to deselect (id or DOM Node)
				var id = dojo.isString(node) ? node : node.id,
					item = this.getItem(id);
				if (item && this.selection[id]) {
					if (this.anchor === dojo.byId(node)) {
						this._removeAnchor();
					}
					delete this.selection[id];
					this._removeItemClass(this.anchor, 'Selected');
				}
				return this;	// self
			},

			selectByBBox: function(left, top, right, bottom, add) {
				//	summary:
				//		selects nodes by bounding box
				//	left: Number:
				//		Left coordinate of the bounding box
				//	top: Number:
				//		Top coordinate of the bounding box
				//	right: Number:
				//		Right coordinate of the bounding box
				//	bottom: Number:
				//		Bottom coordinate of the bounding box
				//	add: Boolean?:
				//		If true, node is added to selection, otherwise current
				//		selection is removed, and node will be the only selection.

				// user has drawn a bounding box ... time to see whether any dom nodes
				// in this container satisfy the bounding box range.
				if (!add) {
					this.selectNone();
				}
				this.forInItems(function(data, id) {
					var node = dojo.byId(id);
					if (node && this._isBoundedByBox(node, left, top, right, bottom)) {
						this.selectNode(id, true);
					}
				}, this);
				return this;	// self
			},

			_isBoundedByBox: function(node, left, top, right, bottom) {
				//	summary:
				//		figures out whether certain coodinates bound a particular
				//		dom node.
				//	node: String|DomNode:
				//		Node to check (id or DOM Node)
				//	left: Number:
				//		Left coordinate of the bounding box
				//	top: Number:
				//		Top coordinate of the bounding box
				//	right: Number:
				//		Right coordinate of the bounding box
				//	bottom: Number:
				//		Bottom coordinate of the bounding box
				return this.conservative ? this._conservativeBBLogic(node, left, top, right, bottom) : this._liberalBBLogic(node, left, top, right, bottom);
			},

			shift: function(toNext, add) {
				//	summary:
				//		shifts the currently selected dnd item forwards and backwards.
				//		One possible use would be to allow a user select different
				//		dnd items using the right and left keys.
				//	toNext: Boolean:
				//		If true, we select the next node, otherwise the previous one.
				//	add: Boolean?:
				//		If true, add to selection, otherwise current selection is
				//		removed before adding any nodes.
				var selectedNodes = this.getSelectedNodes();
				if (selectedNodes && selectedNodes.length) {
					// only delegate to selectNode if at least one node is selected.
					// If multiple nodes are selected assume that we go with
					// the last selected node.
					this.selectNode(this._getNodeId(selectedNodes[selectedNodes.length - 1].id, toNext), add);
				}
			},

			_getNodeId: function(nodeId, toNext) {
				//	summary:
				//		finds a next/previous node in relation to nodeId
				//	nodeId: String:
				//		the id of the node to use as the base node
				//	toNext: Boolean:
				//		If true, we select the next node, otherwise the previous one.
				var allNodes = this.getAllNodes(), newId = nodeId;
				for (var i = 0, l = allNodes.length; i < l; ++i) {
					if (allNodes[i].id == nodeId) {
						// have a match ... make sure we don't go outside
						var j = Math.min(l - 1, Math.max(0, i + (toNext ? 1 : -1)));
						if (i != j) {
							// we should be fine to go with the id the user has requested.
							newId = allNodes[j].id;
						}
						break;
					}
				}
				// if we don't get a match, the newId defaults to the currently selected node
				return newId;
			},

			_conservativeBBLogic: function(node, left, top, right, bottom) {
				//	summary:
				//		logic which determines whether a node is bounded by the
				//		left,top,right,bottom parameters. This function returns true
				//		only if the coordinates of the node parameter are fully
				//		encompassed by the box determined by the left, top, right, bottom parameters.
				var c = dojo.coords(node), t;
				// normalize input
				if (left > right) {
					t = left;
					left = right;
					right = t;
				}
				if (top > bottom) {
					t = top;
					top = bottom;
					bottom = t;
				}
				return c.x >= left && c.x + c.w <= right && c.y >= top && c.y + c.h <= bottom;	// Boolean
			},

			_liberalBBLogic: function(node, left, top, right, bottom) {
				//	summary:
				//		logic which determines whether a node is bounded by the
				//		left,top,right,bottom parameters. Allows for the case where
				//		any section of the box determined by the left,top,right,bottom parameters
				//		overlapping the coordinates of the node parameter constitutes a true
				//		return value
				var c = dojo.position(node), xBounded, yBounded, tlx, tly, brx, bry, leftGreater = false, bottomGreater = false,
				nodeTlx = c.x, nodeTly = c.y, nodeBrx = c.x + c.w, nodeBry = c.y + c.h;
				// tlx, tly represents the x,y coordinates for the top left of the bounding box
				// brx, bry represents the x,y coordinates for the bottom right of the bounding box
				// nodeTlx, nodeTly represents the x,y coordinates for the top left of the dom node
				// nodeBrx, nodeBry represents the x,y coordinates for the bottom right of the dom node
				if (left < right) {
					tlx = left;
					tly = top;
				} else {
					leftGreater = true;
					tlx = right;
					tly = bottom;
				}
				if (top < bottom) {
					bottomGreater = true;
					brx = right;
					bry = bottom;
				} else {
					brx = left;
					bry = top;
					tlx = right;
					tly = bottom;
				}
				if (leftGreater && bottomGreater) {
					// accommodate for the case where the user is drawing from top down and from right to left.
					brx = left;
					bry = bottom;
					tlx = right;
					tly = top;
				}
				xBounded = (nodeTlx >= tlx || nodeBrx <= brx) && (tlx <= nodeBrx && brx >= nodeTlx) || (nodeTlx <= tlx && nodeBrx >= brx);
				yBounded = (tly <= nodeBry && bry >= nodeTly) || (nodeBry >= bry && nodeTly <= bry);
				return xBounded && yBounded;	// Boolean
			}
		}
	);
});