treebasiccontrollerv3.js

初学者

/*
	Copyright (c) 2004-2006, The Dojo Foundation
	All Rights Reserved.

	Licensed under the Academic Free License version 2.1 or above OR the
	modified BSD license. For more information on Dojo licensing, see:

		http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.widget.TreeBasicControllerV3");
dojo.require("dojo.event.*");
dojo.require("dojo.json");
dojo.require("dojo.io.*");
dojo.require("dojo.widget.TreeCommon");
dojo.require("dojo.widget.TreeNodeV3");
dojo.require("dojo.widget.TreeV3");
dojo.widget.defineWidget("dojo.widget.TreeBasicControllerV3", [dojo.widget.HtmlWidget, dojo.widget.TreeCommon], function () {
	this.listenedTrees = {};
}, {listenTreeEvents:["afterSetFolder", "afterTreeCreate", "beforeTreeDestroy"], listenNodeFilter:function (elem) {
	return elem instanceof dojo.widget.Widget;
}, editor:null, initialize:function (args) {
	if (args.editor) {
		this.editor = dojo.widget.byId(args.editor);
		this.editor.controller = this;
	}
}, getInfo:function (elem) {
	return elem.getInfo();
}, onBeforeTreeDestroy:function (message) {
	this.unlistenTree(message.source);
}, onAfterSetFolder:function (message) {
	if (message.source.expandLevel > 0) {
		this.expandToLevel(message.source, message.source.expandLevel);
	}
	if (message.source.loadLevel > 0) {
		this.loadToLevel(message.source, message.source.loadLevel);
	}
}, _focusNextVisible:function (nodeWidget) {
	if (nodeWidget.isFolder && nodeWidget.isExpanded && nodeWidget.children.length > 0) {
		returnWidget = nodeWidget.children[0];
	} else {
		while (nodeWidget.isTreeNode && nodeWidget.isLastChild()) {
			nodeWidget = nodeWidget.parent;
		}
		if (nodeWidget.isTreeNode) {
			var returnWidget = nodeWidget.parent.children[nodeWidget.getParentIndex() + 1];
		}
	}
	if (returnWidget && returnWidget.isTreeNode) {
		this._focusLabel(returnWidget);
		return returnWidget;
	}
}, _focusPreviousVisible:function (nodeWidget) {
	var returnWidget = nodeWidget;
	if (!nodeWidget.isFirstChild()) {
		var previousSibling = nodeWidget.parent.children[nodeWidget.getParentIndex() - 1];
		nodeWidget = previousSibling;
		while (nodeWidget.isFolder && nodeWidget.isExpanded && nodeWidget.children.length > 0) {
			returnWidget = nodeWidget;
			nodeWidget = nodeWidget.children[nodeWidget.children.length - 1];
		}
	} else {
		nodeWidget = nodeWidget.parent;
	}
	if (nodeWidget && nodeWidget.isTreeNode) {
		returnWidget = nodeWidget;
	}
	if (returnWidget && returnWidget.isTreeNode) {
		this._focusLabel(returnWidget);
		return returnWidget;
	}
}, _focusZoomIn:function (nodeWidget) {
	var returnWidget = nodeWidget;
	if (nodeWidget.isFolder && !nodeWidget.isExpanded) {
		this.expand(nodeWidget);
	} else {
		if (nodeWidget.children.length > 0) {
			nodeWidget = nodeWidget.children[0];
		}
	}
	if (nodeWidget && nodeWidget.isTreeNode) {
		returnWidget = nodeWidget;
	}
	if (returnWidget && returnWidget.isTreeNode) {
		this._focusLabel(returnWidget);
		return returnWidget;
	}
}, _focusZoomOut:function (node) {
	var returnWidget = node;
	if (node.isFolder && node.isExpanded) {
		this.collapse(node);
	} else {
		node = node.parent;
	}
	if (node && node.isTreeNode) {
		returnWidget = node;
	}
	if (returnWidget && returnWidget.isTreeNode) {
		this._focusLabel(returnWidget);
		return returnWidget;
	}
}, onFocusNode:function (e) {
	var node = this.domElement2TreeNode(e.target);
	if (node) {
		node.viewFocus();
		dojo.event.browser.stopEvent(e);
	}
}, onBlurNode:function (e) {
	var node = this.domElement2TreeNode(e.target);
	if (!node) {
		return;
	}
	var labelNode = node.labelNode;
	labelNode.setAttribute("tabIndex", "-1");
	node.viewUnfocus();
	dojo.event.browser.stopEvent(e);
	node.tree.domNode.setAttribute("tabIndex", "0");
}, _focusLabel:function (node) {
	var lastFocused = node.tree.lastFocused;
	var labelNode;
	if (lastFocused && lastFocused.labelNode) {
		labelNode = lastFocused.labelNode;
		dojo.event.disconnect(labelNode, "onblur", this, "onBlurNode");
		labelNode.setAttribute("tabIndex", "-1");
		dojo.html.removeClass(labelNode, "TreeLabelFocused");
	}
	labelNode = node.labelNode;
	labelNode.setAttribute("tabIndex", "0");
	node.tree.lastFocused = node;
	dojo.html.addClass(labelNode, "TreeLabelFocused");
	dojo.event.connectOnce(labelNode, "onblur", this, "onBlurNode");
	dojo.event.connectOnce(labelNode, "onfocus", this, "onFocusNode");
	labelNode.focus();
}, onKey:function (e) {
	if (!e.key || e.ctrkKey || e.altKey) {
		return;
	}
	var nodeWidget = this.domElement2TreeNode(e.target);
	if (!nodeWidget) {
		return;
	}
	var treeWidget = nodeWidget.tree;
	if (treeWidget.lastFocused && treeWidget.lastFocused.labelNode) {
		nodeWidget = treeWidget.lastFocused;
	}
	switch (e.key) {
	  case e.KEY_TAB:
		if (e.shiftKey) {
			treeWidget.domNode.setAttribute("tabIndex", "-1");
		}
		break;
	  case e.KEY_RIGHT_ARROW:
		this._focusZoomIn(nodeWidget);
		dojo.event.browser.stopEvent(e);
		break;
	  case e.KEY_LEFT_ARROW:
		this._focusZoomOut(nodeWidget);
		dojo.event.browser.stopEvent(e);
		break;
	  case e.KEY_UP_ARROW:
		this._focusPreviousVisible(nodeWidget);
		dojo.event.browser.stopEvent(e);
		break;
	  case e.KEY_DOWN_ARROW:
		this._focusNextVisible(nodeWidget);
		dojo.event.browser.stopEvent(e);
		break;
	}
}, onFocusTree:function (e) {
	if (!e.currentTarget) {
		return;
	}
	try {
		var treeWidget = this.getWidgetByNode(e.currentTarget);
		if (!treeWidget || !treeWidget.isTree) {
			return;
		}
		var nodeWidget = this.getWidgetByNode(treeWidget.domNode.firstChild);
		if (nodeWidget && nodeWidget.isTreeNode) {
			if (treeWidget.lastFocused && treeWidget.lastFocused.isTreeNode) {
				nodeWidget = treeWidget.lastFocused;
			}
			this._focusLabel(nodeWidget);
		}
	}
	catch (e) {
	}
}, onAfterTreeCreate:function (message) {
	var tree = message.source;
	dojo.event.browser.addListener(tree.domNode, "onKey", dojo.lang.hitch(this, this.onKey));
	dojo.event.browser.addListener(tree.domNode, "onmousedown", dojo.lang.hitch(this, this.onTreeMouseDown));
	dojo.event.browser.addListener(tree.domNode, "onclick", dojo.lang.hitch(this, this.onTreeClick));
	dojo.event.browser.addListener(tree.domNode, "onfocus", dojo.lang.hitch(this, this.onFocusTree));
	tree.domNode.setAttribute("tabIndex", "0");
	if (tree.expandLevel) {
		this.expandToLevel(tree, tree.expandLevel);
	}
	if (tree.loadLevel) {
		this.loadToLevel(tree, tree.loadLevel);
	}
}, onTreeMouseDown:function (e) {
}, onTreeClick:function (e) {
	var domElement = e.target;
	var node = this.domElement2TreeNode(domElement);
	if (!node || !node.isTreeNode) {
		return;
	}
	var checkExpandClick = function (el) {
		return el === node.expandNode;
	};
	if (this.checkPathCondition(domElement, checkExpandClick)) {
		this.processExpandClick(node);
	}
	this._focusLabel(node);
}, processExpandClick:function (node) {
	if (node.isExpanded) {
		this.collapse(node);
	} else {
		this.expand(node);
	}
}, batchExpandTimeout:20, expandAll:function (nodeOrTree) {
	return this.expandToLevel(nodeOrTree, Number.POSITIVE_INFINITY);
}, collapseAll:function (nodeOrTree) {
	var _this = this;
	var filter = function (elem) {
		return (elem instanceof dojo.widget.Widget) && elem.isFolder && elem.isExpanded;
	};
	if (nodeOrTree.isTreeNode) {
		this.processDescendants(nodeOrTree, filter, this.collapse);
	} else {
		if (nodeOrTree.isTree) {
			dojo.lang.forEach(nodeOrTree.children, function (c) {
				_this.processDescendants(c, filter, _this.collapse);
			});
		}
	}
}, expandToNode:function (node, withSelected) {
	n = withSelected ? node : node.parent;
	s = [];
	while (!n.isExpanded) {
		s.push(n);
		n = n.parent;
	}
	dojo.lang.forEach(s, function (n) {
		n.expand();
	});
}, expandToLevel:function (nodeOrTree, level) {
	dojo.require("dojo.widget.TreeTimeoutIterator");
	var _this = this;
	var filterFunc = function (elem) {
		var res = elem.isFolder || elem.children && elem.children.length;
		return res;
	};
	var callFunc = function (node, iterator) {
		_this.expand(node, true);
		iterator.forward();
	};
	var iterator = new dojo.widget.TreeTimeoutIterator(nodeOrTree, callFunc, this);
	iterator.setFilter(filterFunc);
	iterator.timeout = this.batchExpandTimeout;
	iterator.setMaxLevel(nodeOrTree.isTreeNode ? level - 1 : level);
	return iterator.start(nodeOrTree.isTreeNode);
}, getWidgetByNode:function (node) {
	var widgetId;
	var newNode = node;
	while (!(widgetId = newNode.widgetId)) {
		newNode = newNode.parentNode;
		if (newNode == null) {
			break;
		}
	}
	if (widgetId) {
		return dojo.widget.byId(widgetId);
	} else {
		if (node == null) {
			return null;
		} else {
			return dojo.widget.manager.byNode(node);
		}
	}
}, expand:function (node) {
	if (node.isFolder) {
		node.expand();
	}
}, collapse:function (node) {
	if (node.isFolder) {
		node.collapse();
	}
}, canEditLabel:function (node) {
	if (node.actionIsDisabledNow(node.actions.EDIT)) {
		return false;
	}
	return true;
}, editLabelStart:function (node) {
	if (!this.canEditLabel(node)) {
		return false;
	}
	if (!this.editor.isClosed()) {
		this.editLabelFinish(this.editor.saveOnBlur);
	}
	this.doEditLabelStart(node);
}, editLabelFinish:function (save) {
	this.doEditLabelFinish(save);
}, doEditLabelStart:function (node) {
	if (!this.editor) {
		dojo.raise(this.widgetType + ": no editor specified");
	}
	this.editor.open(node);
}, doEditLabelFinish:function (save, server_data) {
	if (!this.editor) {
		dojo.raise(this.widgetType + ": no editor specified");
	}
	var node = this.editor.node;
	var editorTitle = this.editor.getContents();
	this.editor.close(save);
	if (save) {
		var data = {title:editorTitle};
		if (server_data) {
			dojo.lang.mixin(data, server_data);
		}
		if (node.isPhantom) {
			var parent = node.parent;
			var index = node.getParentIndex();
			node.destroy();
			dojo.widget.TreeBasicControllerV3.prototype.doCreateChild.call(this, parent, index, data);
		} else {
			var title = server_data && server_data.title ? server_data.title : editorTitle;
			node.setTitle(title);
		}
	} else {
		if (node.isPhantom) {
			node.destroy();
		}
	}
}, makeDefaultNode:function (parent, index) {
	var data = {title:parent.tree.defaultChildTitle};
	return dojo.widget.TreeBasicControllerV3.prototype.doCreateChild.call(this, parent, index, data);
}, runStages:function (check, prepare, make, finalize, expose, args) {
	if (check && !check.apply(this, args)) {
		return false;
	}
	if (prepare && !prepare.apply(this, args)) {
		return false;
	}
	var result = make.apply(this, args);
	if (finalize) {
		finalize.apply(this, args);
	}
	if (!result) {
		return result;
	}
	if (expose) {
		expose.apply(this, args);
	}
	return result;
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {createAndEdit:function (parent, index) {
	var data = {title:parent.tree.defaultChildTitle};
	if (!this.canCreateChild(parent, index, data)) {
		return false;
	}
	var child = this.doCreateChild(parent, index, data);
	if (!child) {
		return false;
	}
	this.exposeCreateChild(parent, index, data);
	child.isPhantom = true;
	if (!this.editor.isClosed()) {
		this.editLabelFinish(this.editor.saveOnBlur);
	}
	this.doEditLabelStart(child);
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canClone:function (child, newParent, index, deep) {
	return true;
}, clone:function (child, newParent, index, deep) {
	return this.runStages(this.canClone, this.prepareClone, this.doClone, this.finalizeClone, this.exposeClone, arguments);
}, exposeClone:function (child, newParent) {
	if (newParent.isTreeNode) {
		this.expand(newParent);
	}
}, doClone:function (child, newParent, index, deep) {
	var cloned = child.clone(deep);
	newParent.addChild(cloned, index);
	return cloned;
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canDetach:function (child) {
	if (child.actionIsDisabledNow(child.actions.DETACH)) {
		return false;
	}
	return true;
}, detach:function (node) {
	return this.runStages(this.canDetach, this.prepareDetach, this.doDetach, this.finalizeDetach, this.exposeDetach, arguments);
}, doDetach:function (node, callObj, callFunc) {
	node.detach();
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canDestroyChild:function (child) {
	if (child.parent && !this.canDetach(child)) {
		return false;
	}
	return true;
}, destroyChild:function (node) {
	return this.runStages(this.canDestroyChild, this.prepareDestroyChild, this.doDestroyChild, this.finalizeDestroyChild, this.exposeDestroyChild, arguments);
}, doDestroyChild:function (node) {
	node.destroy();
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canMoveNotANode:function (child, parent) {
	if (child.treeCanMove) {
		return child.treeCanMove(parent);
	}
	return true;
}, canMove:function (child, newParent) {
	if (!child.isTreeNode) {
		return this.canMoveNotANode(child, newParent);
	}
	if (child.actionIsDisabledNow(child.actions.MOVE)) {
		return false;
	}
	if (child.parent !== newParent && newParent.actionIsDisabledNow(newParent.actions.ADDCHILD)) {
		return false;
	}
	var node = newParent;
	while (node.isTreeNode) {
		if (node === child) {
			return false;
		}
		node = node.parent;
	}
	return true;
}, move:function (child, newParent, index) {
	return this.runStages(this.canMove, this.prepareMove, this.doMove, this.finalizeMove, this.exposeMove, arguments);
}, doMove:function (child, newParent, index) {
	child.tree.move(child, newParent, index);
	return true;
}, exposeMove:function (child, newParent) {
	if (newParent.isTreeNode) {
		this.expand(newParent);
	}
}});
dojo.lang.extend(dojo.widget.TreeBasicControllerV3, {canCreateChild:function (parent, index, data) {
	if (parent.actionIsDisabledNow(parent.actions.ADDCHILD)) {
		return false;
	}
	return true;
}, createChild:function (parent, index, data) {
	if (!data) {
		data = {title:parent.tree.defaultChildTitle};
	}
	return this.runStages(this.canCreateChild, this.prepareCreateChild, this.doCreateChild, this.finalizeCreateChild, this.exposeCreateChild, [parent, index, data]);
}, prepareCreateChild:function () {
	return true;
}, finalizeCreateChild:function () {
}, doCreateChild:function (parent, index, data) {
	var newChild = parent.tree.createNode(data);
	parent.addChild(newChild, index);
	return newChild;
}, exposeCreateChild:function (parent) {
	return this.expand(parent);
}});