jeasyui.extensions.tree.js

/**
	* jQuery EasyUI 1.3.6
	* Copyright (c) 2009-2014 www.jeasyui.com. All rights reserved.
	*
	* Licensed under the GPL or commercial licenses
	* To use it on other terms please contact author: info@jeasyui.com
	* http://www.gnu.org/licenses/gpl.txt
	* http://www.jeasyui.com/license_commercial.php
	*
	* jQuery EasyUI tree Extensions 1.0 beta
	* jQuery EasyUI tree 组件扩展
	* jeasyui.extensions.tree.js
	* 二次开发 流云
	* 最近更新：2014-04-09
	*
	* 依赖项：
	* 1、jquery.jdirk.js v1.0 beta late
	* 2、jeasyui.extensions.js v1.0 beta late
	* 3、jeasyui.extensions.menu.js v1.0 beta late
	* 4、jeasyui.extensions.panel.js v1.0 beta late
	* 5、jeasyui.extensions.window.js v1.0 beta late
	* 6、jeasyui.extensions.dialog.js v1.0 beta late
	*
	* Copyright (c) 2013-2014 ChenJianwei personal All rights reserved.
	* http://www.chenjianwei.org
	*/
	(function ($, undefined) {
	$.fn.tree.extensions = {};
	/******************** initExtensions Methods Begin ********************/
	function isRootNode(treeTarget, target) {
	var t = $(treeTarget);
	target = $(target)[0];
	return $.array.contains(t.tree("getRoots"), target, function (t1, t2) {
	return t1.target == t2;
	});
	};
	function showOption(treeTarget, target) {
	var t = $(treeTarget), opts, pos;
	if (target) {
	target = $(target)[0];
	opts = t.tree("getNode", target);
	pos = $(target).offset();
	} else {
	opts = t.tree("options");
	pos = t.offset();
	}
	$.extend(pos, { left: pos.left + 25, top: pos.top + 15 });
	$.easyui.showOption(opts, pos);
	};
	function getLevel(treeTarget, target) {
	var t = $(treeTarget), node = $(target);
	if (!t[0] || !node[0] || !node.is(".tree-node[node-id]") || !$.contains(t[0], node[0])) { return 0; }
	return node.parentsUntil("ul.tree", "ul").length + 1;
	};
	function moveNode(treeTarget, param) {
	if (!param || !param.source || !param.target || !param.point) { return; }
	if (!$.array.contains(["append", "top", "bottom"], param.point)) { param.point = "append"; }
	param.source = $(param.source)[0]; param.target = $(param.target)[0];
	if (param.source == param.target) { return; }
	var t = $(treeTarget), opts = t.tree("options");
	if ($.isFunction(opts.onBeforeDrop) && opts.onBeforeDrop.call(treeTarget, param.target, param.source, param.point) == false) { return; }
	if (t.tree("isParent", { target1: param.source, target2: param.target })) { return; }
	var node = t.tree("pop", param.source);
	switch (param.point) {
	case "append": t.tree("append", { parent: param.target, data: [node] }); break;
	case "top": t.tree("insert", { before: param.target, data: node }); break;
	case "bottom": t.tree("insert", { after: param.target, data: node }); break;
	default: t.tree("append", { parent: param.target, data: [node] }); break;
	}
	if (node && $.isFunction(opts.onDrop)) { opts.onDrop.call(treeTarget, param.target, param.source, param.point); }
	};
	function shiftNode(treeTarget, param) {
	if (!param || !param.target || !param.point || !$.array.contains(["up", "upLevel", "down", "downLevel"], param.point)) { return; }
	param.target = $(param.target)[0];
	var t = $(treeTarget), source = param.target, targetNode;
	switch (param.point) {
	case "up": targetNode = t.tree("prev", source); break;
	case "upLevel": targetNode = t.tree("getParent", source); break;
	case "down": targetNode = t.tree("next", source); break;
	case "downLevel": targetNode = t.tree("prev", source); break;
	default: break;
	}
	if (!targetNode) { return; }
	t.tree("move", { source: source, target: targetNode.target, point: param.point == "up" ? "top" : (param.point == "downLevel" ? "append" : "bottom") });
	};
	function compareNode(target, param) {
	if (isChild(target, param)) { return "child"; }
	if (isParent(target, param)) { return "parent"; }
	if (isSibling(target, param)) { return "sibling"; }
	return "normal";
	};
	function isChild(target, param) {
	var t = $(target),
	target1 = $(param.target1)[0], target2 = $(param.target2)[0];
	var children = t.tree("getChildren", target2);
	return $.array.some(children, function (val) { return val.target == target1; });
	};
	function isParent(target, param) {
	var t = $(target),
	target1 = $(param.target1)[0], target2 = $(param.target2)[0];
	var children = t.tree("getChildren", target1);
	return $.array.some(children, function (val) { return val.target == target2; });
	};
	function isSibling(target, param) {
	var t = $(target),
	target1 = $(param.target1)[0], target2 = $(param.target2)[0],
	p1 = t.tree("getParent", target1), p2 = t.tree("getParent", target2);
	return p1.target == p2.target;
	};
	function getNextNode(treeTarget, target) {
	var item = $(target);
	if (!item.hasClass("tree-node")) { return null; }
	var target = item[0], next = item.closest("li").next().children("div.tree-node");
	if (!next.length) { return null; }
	return next.length ? $(treeTarget).tree("getNode", next[0]) : null;
	};
	function getPrevNode(treeTarget, target) {
	var item = $(target);
	if (!item.hasClass("tree-node")) { return null; }
	var target = item[0], prev = item.closest("li").prev().children("div.tree-node");
	if (!prev.length) { return null; }
	return prev.length ? $(treeTarget).tree("getNode", prev[0]) : null;
	};
	function getNears(treeTarget, target) {
	var t = $(treeTarget); target = $(target);
	if (!$.contains(t[0], target[0]) || !target.is("div.tree-node")) { return null; }
	return target.closest("ul").find("li>div.tree-node").map(function () {
	return t.tree("getNode", this);
	});
	};
	function getNearChildren(treeTarget, target) {
	var t = $(treeTarget); target = $(target);
	if (!$.contains(t[0], target[0]) || !target.is("div.tree-node")) {
	return null;
	}
	return target.siblings("ul").find("li>div.tree-node").map(function () {
	return t.tree("getNode", this);
	});
	};
	function unselect(treeTarget, target) {
	$(target).removeClass("tree-node-selected");
	};
	function remoteLoad(target, param) {
	var t = $(target);
	if (!param) { return t.tree("reload"); }
	if (typeof param == "string") {
	t.tree("options").url = param;
	return remoteLoad(target, {});
	}
	var opts = t.tree("options"), queryParams = opts.queryParams;
	opts.queryParams = $.extend({}, queryParams, param);
	t.tree("reload");
	};
	function setNodeIcon(target, param) {
	if (!param || !param.target || !param.iconCls) { return; }
	$(target).tree("update", { target: param.target, iconCls: param.iconCls })
	};
	function setNodeText(target, param) {
	if (!param || !param.target || !param.text) { return; }
	$(target).tree("update", { target: param.target, text: param.text })
	};
	/******************** initExtensions Methods End ********************/
	function initAutoToggle(t, opts, exts) {
	exts.onClickBak = opts.onClick;
	opts.onClick = function (node) {
	if ($.isFunction(exts.onClickBak)) { exts.onClickBak.apply(this, arguments); }
	if (opts.toggleOnClick) { t.tree("toggle", node.target); }
	};
	};
	function initContextMenu(t, opts, exts) {
	exts.onContextMenuBak = opts.onContextMenu;
	opts.onContextMenu = function (e, node) {
	if ($.isFunction(exts.onContextMenuBak)) { exts.onContextMenuBak.apply(this, arguments); }
	if (opts.selectOnContextMenu) { t.tree("select", node.target); }
	if (opts.enableContextMenu) {
	e.preventDefault();
	var items = parseContextMenuItems(t, opts, e, node);
	if (opts.autoBindDblClick && opts.dblClickMenuIndex >= 0 && $.util.likeArray(opts.contextMenu) && !$.util.isString(opts.contextMenu)
	&& opts.contextMenu.length > opts.dblClickMenuIndex) {
	items[opts.dblClickMenuIndex].bold = true;
	}
	$.easyui.showMenu({ items: items, left: e.pageX, top: e.pageY });
	}
	};
	};
	function initBindDblClickEvent(t, opts, exts) {
	if (!$.array.likeArray(opts.contextMenu) || $.util.isString(opts.contextMenu) ||
	!opts.contextMenu.length || !opts.autoBindDblClick) { return; }
	opts.onDblClickBak = opts.onDblClick;
	opts.onDblClick = function (node) {
	if ($.isFunction(exts.onDblClickBak)) { exts.onDblClickBak.apply(this, arguments); }
	var items = parseContextMenuItems(t, opts, null, node);
	if (opts.dblClickMenuIndex >= 0 && items.length > opts.dblClickMenuIndex) {
	var item = items[opts.dblClickMenuIndex], handler = item.handler || item || onclick;
	handler(null, node, t, item, null);
	}
	};
	};
	function parseContextMenuItems(t, opts, e, node) {
	var toggle = opts.toggleMenu, move = opts.moveMenu;
	if (typeof toggle == "object") {
	toggle = $.extend({}, { expand: true, expandAll: true, collapse: true, collapseAll: true, submenu: false }, toggle);
	}
	if (typeof move == "object") {
	move = $.extend({}, { up: false, upLevel: false, down: false, downLevel: false, submenu: false }, move);
	}
	var mExpandAll = { text: "展开当前所有", iconCls: "icon-metro-expand", disabled: !(toggle == true || toggle.expandAll == true), handler: function () { t.tree("expandAll", node.target); } };
	var mExpand = { text: "展开当前", iconCls: "icon-metro-expand2", disabled: !(toggle == true || toggle.expand == true), handler: function () { t.tree("expand", node.target); } };
	var mCollapse = { text: "折叠当前", iconCls: "icon-metro-contract2", disabled: !(toggle == true || toggle.collapse == true), handler: function () { t.tree("collapse", node.target); } };
	var mCollapseAll = { text: "折叠当前所有", iconCls: "icon-metro-contract", disabled: !(toggle == true || toggle.collapseAll == true), handler: function () { t.tree("collapseAll", node.target); } };
	var mUpLevel = { text: "上移一级", iconCls: "icon-standard-arrow-up", disabled: !(move == true || move.upLevel == true), handler: function () { t.tree("shift", { point: "upLevel", target: node.target }); } };
	var mUp = { text: "上移", iconCls: "icon-standard-up", disabled: !(move == true || move.up == true), handler: function () { t.tree("shift", { point: "up", target: node.target }); } };
	var mDown = { text: "下移", iconCls: "icon-standard-down", disabled: !(move == true || move.down == true), handler: function () { t.tree("shift", { point: "down", target: node.target }); } };
	var mDownLevel = { text: "下移一级", iconCls: "icon-standard-arrow-down", disabled: !(move == true || move.downLevel == true), handler: function () { t.tree("shift", { point: "downLevel", target: node.target }); } };
	var mOpts = {
	text: "显示 Option", iconCls: "icon-standard-application-form", disabled: !opts.showOption, children: [
	{ text: "树控件 Option", iconCls: "icon-hamburg-category", handler: function () { t.tree("showOption"); } },
	{ text: "该节点 Option", iconCls: "tree-icon tree-file", handler: function () { t.tree("showOption", node.target); } }
	]
	};
	var menus = [];
	var toggleMenu = [mExpandAll, mExpand, mCollapse, mCollapseAll], moveMenu = [mUpLevel, mUp, mDown, mDownLevel];
	if (t.tree("isRoot", node.target)) {
	$.array.insertRange(toggleMenu, 0, [
	{ text: "展开所有", iconCls: "icon-standard-arrow-out", handler: function () { t.tree("expandAll"); } },
	{ text: "折叠所有", iconCls: "icon-standard-arrow-in", handler: function () { t.tree("collapseAll"); } }, "-"
	]);
	}
	if ($.array.likeArray(opts.contextMenu)) { $.array.merge(menus, opts.contextMenu, "-"); }
	if (opts.showOption) { $.array.merge(menus, mOpts, "-"); }
	$.array.merge(menus, typeof toggle == "object" && !toggle.submenu
	? $.array.merge(toggleMenu, "-") : [{ text: "展开/折叠", iconCls: "", disabled: !toggle, children: toggleMenu }, "-"]);
	$.array.merge(menus, typeof move == "object" && !move.submenu
	? moveMenu : { text: "上/下移(级)", iconCls: "", disabled: !move, children: moveMenu });
	return parseContextMenuMap(e, node, menus, t);
	};
	function parseContextMenuMap(e, node, menus, t) {
	return $.array.map(menus, function (value) {
	if (!value || $.util.isString(value)) { return value; }
	var ret = $.extend({}, value);
	ret.id = $.isFunction(value.id) ? value.id.call(ret, e, node, t) : value.id;
	ret.text = $.isFunction(value.text) ? value.text.call(ret, e, node, t) : value.text;
	ret.iconCls = $.isFunction(value.iconCls) ? value.iconCls.call(ret, e, node, t) : value.iconCls;
	ret.disabled = $.isFunction(value.disabled) ? value.disabled.call(ret, e, node, t) : value.disabled;
	ret.hideOnClick = $.isFunction(value.hideOnClick) ? value.hideOnClick.call(ret, e, node, t) : value.hideOnClick;
	ret.onclick = $.isFunction(value.onclick) ? function (e, item, menu) { value.onclick.call(this, e, node, t, item, menu); } : value.onclick;
	ret.handler = $.isFunction(value.handler) ? function (e, item, menu) { value.handler.call(this, e, node, t, item, menu); } : value.handler;
	if (ret.children && ret.children.length) { ret.children = parseContextMenuMap(e, node, ret.children, t); }
	return ret;
	});
	};
	/******************** initExtensions Begin ********************/
	var initExtensions = $.fn.tree.extensions.initExtensions = function (t, opts) {
	var exts = opts._extensions ? opts._extensions : opts._extensions = {};
	if (exts._initialized) { return; }
	initAutoToggle(t, opts, exts);
	initContextMenu(t, opts, exts);
	initBindDblClickEvent(t, opts, exts);
	exts._initialized = true;
	};
	var parseQueryParams = $.fn.tree.extensions.parseQueryParams = function (opts, param) {
	var ret = $.extend({}, param, opts.queryParams);
	return $.util.parseMapFunction(ret);
	};
	var loader = $.fn.tree.extensions.loader = function (param, success, error) {
	var t = $(this), opts = t.tree("options");
	initExtensions(t, opts);
	if (!opts.url) { return false; }
	param = parseQueryParams(opts, param);
	$.ajax({
	type: opts.method, url: opts.url, data: param, dataType: "json",
	success: function (data) { success(data); },
	error: function () { error.apply(this, arguments); }
	});
	};
	var _onExpand = $.fn.tree.defaults.onExpand;
	var onExpand = $.fn.tree.extensions.onExpand = function (node) {
	if ($.isFunction(_onExpand)) { _onExpand.apply(this, arguments); }
	var t = $(this), opts = t.tree("options");
	if (opts.onlyNodeExpand) {
	var nodes = t.tree("getNears", node.target), animate = opts.animate
	opts.animate = false;
	$.each($.array.filter(nodes, function (val) { return val.target != node.target && val.state == "open"; }), function () {
	t.tree("collapse", this.target);
	});
	opts.animate = animate;
	}
	};
	var _loadFilter = $.fn.tree.defaults.loadFilter;
	var loadFilter = $.fn.tree.extensions.loadFilter = function (data, parent) {
	if ($.isFunction(_loadFilter)) { data = _loadFilter.apply(this, arguments); }
	data = $.array.likeArray(data) && !$.util.isString(data) ? data : [];
	if (!data.length) { return data; }
	var t = $(this), opts = t.tree("options");
	return opts.dataPlain ? $.fn.tree.extensions.dataPlainConverter(data, opts) : data;
	};
	/******************** initExtensions End ********************/
	$.fn.tree.extensions.dataPlainConverter = function (data, opts) {
	data = data || [];
	var ret = data, idField = opts.idField || "id", parentField = opts.parentField || "pid";
	if (opts.dataPlain) {
	var roots = $.array.filter(data, function (val) {
	if (val[parentField] == null || val[parentField] == undefined) { return true; }
	return !$.array.some(data, function (value) { return val[parentField] == value[idField]; });
	});
	var findChildren = function (array, value) {
	var temps = $.array.filter(array, function (val) {
	return val[parentField] == null || val[parentField] == undefined ? false : val[parentField] == value[idField];
	});
	return $.array.map(temps, function (val) {
	var children = findChildren(array, val);
	if (children.length) {
	val.children = $.array.likeArray(val.children) && !$.util.isString(val.children) ? val.children : [];
	$.array.merge(val.children, children);
	}
	return val;
	});
	};
	ret = $.array.map(roots, function (val) {
	var children = findChildren(data, val);
	if (children.length) {
	val.children = $.array.likeArray(val.children) && !$.util.isString(val.children) ? val.children : [];
	$.array.merge(val.children, children);
	}
	return val;
	});
	}
	return ret;
	};
	$.fn.tree.extensions.cascadeToArray = function (data) {
	if ($.util.isEmptyObjectOrNull(data)) { return []; }
	if (!$.util.likeArrayNotString(data)) { data = [data]; }
	var ret = [], getNodeArray = function (node) {
	var tmp = $.extend({}, node), array = [tmp];
	if (!tmp.children || (tmp.children && !$.util.likeArrayNotString(tmp.children))) {
	return array;
	}
	$.each(tmp.children, function (i, n) {
	$.array.merge(array, getNodeArray(n));
	});
	tmp.children = undefined;
	return array;
	};
	$.each(data, function (i, n) {
	$.array.merge(ret, getNodeArray(n));
	});
	return ret;
	};
	var methods = $.fn.tree.extensions.methods = {
	// 扩展 easyui-tree 的自定义方法；判断制定的 tree-node 是否为根节点；该方法定义如下参数：
	// target: 用于判断的 tree-node 的 jQuery 或 DOM 对象。
	// 返回值：如果指定的 jQuery 对象是该 easyui-tree 的根节点，则返回 true，否则返回 false。
	isRoot: function (jq, target) { return isRootNode(jq[0], target); },
	// 扩展 easyui-tree 的自定义方法；用于显示指定节点或树控件的属性信息；该方法定义如下参数：
	// target: 要显示属性信息的 tree-node 的 jQuery 或 DOM 对象；该参数可选；如果不定义该参数，则显示树控件的属性信息；
	// 返回值：返回表示当前 easyui-tree 组件的 jQuery 对象。
	showOption: function (jq, target) { return jq.each(function () { showOption(this, target); }); },
	// 扩展 easyui-tree 的自定义方法；用于获取指定节点的级别；该方法的参数 target 表示要获取级别的 tree-node 节点的 jQuery 或 DOM 对象；
	// 返回值：如果 target 表示的 DOM 对象存在于此 easyui-tree，则返回表示其所在节点级别的数字(从 1 开始计数)，否则返回 0。
	getLevel: function (jq, target) { return getLevel(jq[0], target); },
	// 扩展 easyui-tree 的自定义方法；移动指定的节点到另一个位置；该方法定义如下参数：
	// param: 这是一个 JSON-Object，该对象定义如下属性：
	// target: 表示目标位置的 tree-node 的 jQuery 或 DOM 对象；
	// source: 表示要移动的 tree-node 的 jQuery 或 DOM 对象；
	// point: 表示移动到目标节点 target 的位置，String 类型，可选的值包括：
	// "append": 表示追加为目标节点 target 的子节点，默认值；
	// "top": 表示移动到目标节点 target 的上一格位置；
	// "bottom": 表示追加为目标节点 target 的下一格位置；
	// 返回值：返回表示当前 easyui-tree 组件的 jQuery 对象。
	move: function (jq, param) { return jq.each(function () { moveNode(this, param); }); },
	// 扩展 easyui-tree 的自定义方法；移动指定节点的位置；该方法定义如下参数：
	// param: 这是一个 JSON-Object，该对象定义如下属性：
	// target: 表示要移动的 tree-node 的 jQuery 或 DOM 对象；
	// point: 表示移动 target 的方式，String 类型，可选的值报错：
	// "up": 表示将 target 所表示的 tree-node 移动到上一格位置；
	// "upLevel": 表示将 target 所表示的 tree-node 移动到上一级的末尾；
	// "down": 表示将 target 所表示的 tree-node 移动到下一格位置；
	// "downLevel":表示将 target 所表示的 tree-node 移动到下一级的末尾；
	// 如果不定义该值或者该值为空或该值不是上面四个之一，则不进行任何操作；
	// 返回值：返回表示当前 easyui-tree 组件的 jQuery 对象。
	shift: function (jq, param) { return jq.each(function () { shiftNode(this, param); }); },
	// 扩展 easyui-tree 的自定义方法；判断两个 tree-node 之间的关系；该方法定义如下参数：
	// param： 这是一个 JSON-Object，该对象定义如下属性：
	// target1: 用于判断的第一个 tree-node 的 jQuery 或 DOM 对象；
	// target2: 用于判断的第二个 tree-node 的 jQuery 或 DOM 对象；
	// 返回值：返回一个 String 类型的值：
	// 如果 target1 是 target2 的子节点，则返回 "child"；
	// 如果 target1 是 target2 的父节点，则返回 "parent"；
	// 如果 target1 和 target2 是具有同一个父级节点的平级节点，则返回 "sibling"；
	// 如果 target1 和 target2 既不是父子级关系，也不是具有同一个父级节点的平级节点关系，则返回 "normal"；
	compare: function (jq, param) { return compareNode(jq[0], param); },
	// 扩展 easyui-tree 的自定义方法；判断一个节点是否为另一个节点的子节点；该方法定义如下参数：
	// param： 这是一个 JSON-Object，该对象定义如下属性：
	// target1: 用于判断的第一个 tree-node 的 jQuery 或 DOM 对象；
	// target2: 用于判断的第二个 tree-node 的 jQuery 或 DOM 对象；
	// 返回值：如果 tree-node target1 是 tree-node target2 的子节点，则返回 true，否则返回 false。
	isChild: function (jq, param) { return isChild(jq[0], param); },
	// 扩展 easyui-tree 的自定义方法；判断一个节点是否为另一个节点的父节点；该方法定义如下参数：
	// param： 这是一个 JSON-Object，该对象定义如下属性：
	// target1: 用于判断的第一个 tree-node 的 jQuery 或 DOM 对象；
	// target2: 用于判断的第二个 tree-node 的 jQuery 或 DOM 对象；
	// 返回值：如果 tree-node target1 是 tree-node target2 的父节点，则返回 true，否则返回 false。
	isParent: function (jq, param) { return isParent(jq[0], param); },
	// 扩展 easyui-tree 的自定义方法；判断一个节点是否和另一个节点为具有同一个父节点的平级节点；该方法定义如下参数：
	// param： 这是一个 JSON-Object，该对象定义如下属性：
	// target1: 用于判断的第一个 tree-node 的 jQuery 或 DOM 对象；
	// target2: 用于判断的第二个 tree-node 的 jQuery 或 DOM 对象；
	// 返回值：如果 tree-node target1 和 tree-node target2 是具有同一个父级节点的平级节点，则返回 true，否则返回 false。
	isSibling: function (jq, param) { return isSibling(jq[0], param); },
	// 扩展 easyui-tree 的自定义方法；获取指定节点的平级下一格位置的 tree-node 节点；该方法定义如下参数：
	// target: 指定的表示 tree-node 的 jQuery 或 DOM 对象。
	// 返回值：返回 tree-node target 的同级别下一格位置的 tree-node 节点 node 对象；该 node 对象含有如下属性：
	// id、text、iconCls、checked、state、attributes、target；
	// 如果该 tree-node target 为当前级别的最后一个节点即没有下一格节点；则返回 null。
	next: function (jq, target) { return getNextNode(jq[0], target); },
	// 扩展 easyui-tree 的自定义方法；获取指定节点的平级上一格位置的 tree-node 节点；该方法定义如下参数：
	// target: 指定的表示 tree-node 的 jQuery 或 DOM 对象。
	// 返回值：返回 tree-node target 的同级别上一格位置的 tree-node 节点对象；该 tree-node 对象含有如下属性：
	// id、text、iconCls、checked、state、attributes、target；
	// 如果该 tree-node target 为当前级别的第一个节点即没有上一格节点；则返回 null。
	prev: function (jq, target) { return getPrevNode(jq[0], target); },
	// 扩展 easyui-tree 的自定义方法；获取指定节点的同级所有节点(包含自身)；该方法定义如下参数：
	// target: 指定的表示 tree-node 的 jQuery 或 DOM 对象。
	// 返回值：返回 tree-node target 的同级别(具有和当前 target 同一个父级节点)所有节点构成的一个数组对象；
	// 数组中每一个元素都是一个包含属性 id、text、iconCls、checked、state、attributes、target 的 tree-node 对象。
	// 如果传入的参数 target 是根节点或者未定义 target 参数，则该方法和 getRoots 方法返回的值相同；
	// 如果传入的参数 target 不是一个 div.tree-node 或者其不包含在当前 easyui-tree 中，则返回 null。
	getNears: function (jq, target) { return getNears(jq[0], target); },
	// 扩展 easyui-tree 的自定义方法；获取指定节点的下一级所有节点；该方法定义如下参数：
	// target: 指定的表示 tree-node 的 jQuery 或 DOM 对象。
	// 返回值：返回 tree-node target 的下一级所有节点构成的一个数组对象；
	// 数组中每一个元素都是一个包含属性 id、text、iconCls、checked、state、attributes、target 的 tree-node 对象。
	// 如果传入的参数 target 没有子节点，则返回一个包含 0 个元素的数组。
	// 如果传入的参数 target 不是一个 div.tree-node 或者其不包含在当前 easyui-tree 中，则返回 null。
	// 备注：该方法和 getChildren 的不同之处在于，getChildren 方法返回的是 target 下的所有子节点内容；
	getNearChildren: function (jq, target) { return getNearChildren(jq[0], target); },
	// 扩展 easyui-tree 的自定义方法；用于取消指定树节点的选择状态；该方法定义如下参数：
	// target: 指定的表示 tree-node 的 jQuery 或 DOM 对象。
	// 返回值：返回表示当前 easyui-tree 组件的 jQuery 对象。
	unselect: function (jq, target) { return jq.each(function () { unselect(this, target); }); },
	// 扩展 easyui-tree 的自定义方法；请求远程服务器地址并加载数据，并将返回的数据设置为当前 easyui-tree 的节点数据集；该方法定义如下参数：
	// param：表示要进行远程请求的方式，该参数可以定义为以下类型：
	// String 类型值：表示作为远程数据请求的目标 url 地址；
	// JSON-Object 类型值：表示发送至远程服务器的查询参数；
	// 如果未定义参数 param，则相当于直接执行不带参数 { id } 的 reload 方法(reload 方法的执行默认会将指定节点的 id 作为参数发送到远程服务器地址)。
	// 返回值：返回表示当前 easyui-tree 组件的 jQuery 对象。
	load: function (jq, param) { return jq.each(function () { remoteLoad(this, param); }); },
	// 扩展 easyui-tree 的自定义方法；设置指定节点的图标；该方法定义如下参数：
	// param: JSON-Object 类型值，该对象包含如下属性定义：
	// target: 表示要设置图标的 easyui-tree node HTML-DOM 对象；
	// iconCls:表示要设置的节点样式；
	// 返回值：返回表示当前 easyui-tree 组件的 jQuery 对象。
	setIcon: function (jq, param) { return jq.each(function () { setNodeIcon(this, param); }); },
	// 扩展 easyui-tree 的自定义方法；设置指定节点的显示文本；该方法定义如下参数：
	// param: JSON-Object 类型值，该对象包含如下属性定义：
	// target: 表示要设置图标的 easyui-tree node HTML-DOM 对象；
	// text : 表示要设置的显示文本值；
	// 返回值：返回表示当前 easyui-tree 组件的 jQuery 对象。
	setText: function (jq, param) { return jq.each(function () { setNodeText(this, param); }); }
	};
	var defaults = $.fn.tree.extensions.defaults = {
	// 增加 easyui-tree 的自定义扩展属性；
	// 该属性表示当设定了属性 contextMenu 时，是否将双击数据行 onDblClick 事件的响应函数
	// 设置为 contextMenu 的第一个菜单项的点击响应函数，并将该菜单项的字体加粗；
	// Boolean 类型值，默认为 true；
	// 备注：当设置了自定义属性 contextMenu 时候，该功能方有效。
	// 自动绑定的 onClick 的回调函数中将会调用 contextMenu 的第 "dblClickMenuIndex" 个菜单项的点击响应函数，但是回调函数中不能用到参数 e 和 menu。
	autoBindDblClick: true,
	// 增加 easyui-tree 的自定义扩展属性；
	// 该属性表示当设定了属性 autoBindDblClick: true，双击行数据触发的右键菜单项事件的索引号；
	// 意即触发第几个右键菜单项上的事件。
	// Number 类型值，从 0 开始计数，默认为 0；
	// 备注：当设置了自定义属性 autoBindDblClick: true 时，该功能方有效；如果此索引值超出菜单数量范围，则无效。
	dblClickMenuIndex: 0,
	// 扩展 easyui-tree 的自定义属性，表示当前 easyui-tree 控件是否支持平滑数据格式。
	// 当支持平滑数据格式时，数据元素中不需要通过指定 children 来指定子节点，而是支持通过 pid 属性来指示其父级节点。
	// Boolean 类型值，默认为 false。
	dataPlain: false,
	// 扩展 easyui-treegrid 的自定义属性，表示当前 easyui-treeg 控件支持平滑数据格式时，程序用哪个 field 表示当前行数据的父级节点 idField 值
	// String 类型值，默认为 "pid"。
	parentField: "pid",
	// 扩展 easyui-tree 的自定义属性，表示当右键点击 tree-node 时，是否自动选择被点击的 tree-node 对象；
	// Boolean 类型值，默认为 false；
	selectOnContextMenu: false,
	// 扩展 easyui-tree 的自定义属性，表示当左键点击带有子节点的条目时，是否自动展开/折叠相应节点。
	// Boolean 类型，默认为 false。
	// 备注：该功能不会影响到 easyui-tree 的原生事件 onClick。
	toggleOnClick: false,
	// 扩展 easyui-tree 的自定义属性，表示同一级菜单节点下，只允许一个节点被展开。
	// Boolean 类型，默认为 false。
	// 当该属性设置为 true 时，建议同时把 animate 属性设置为 false，以免影响菜单联动折叠时的美观效果。
	onlyNodeExpand: false,
	// 扩展 easyui-tree 的自定义属性，表示是否启用当前 easyui-tree 组件的右键菜单。
	// Boolean 类型，默认为 true。
	// 备注：该功能不会影响到 easyui-tree 的原生事件 onContextMenu。
	enableContextMenu: true,
	// 扩展 easyui-tree 的自定义属性，表示当前 easyui-tree 的右键菜单；
	// 这是一个数组类型，数组中的每一个元素都是一个 JSON-Object，该 JSON-Object 定义如下属性：
	// id: 表示菜单项的 id；
	// text: 表示菜单项的显示文本；
	// iconCls: 表示菜单项的左侧显示图标；
	// disabled: 表示菜单项是否被禁用(禁用的菜单项点击无效)；
	// hideOnClick: 表示该菜单项点击后整个右键菜单是否立即自动隐藏；
	// bold: Boolean 类型值，默认为 false；表示该菜单项是否字体加粗；
	// style: JSON-Object 类型值，默认为 null；表示要附加到该菜单项的样式；
	// handler: 表示菜单项的点击事件，该事件函数格式为 function(e, node, tree, item, menu)，其中 this 指向菜单项本身
	// 备注：当 enableContextMenu 属性设置为 true 时，该属性才有效。
	// 备注：该功能不会影响到 easyui-tree 的原生事件 onContextMenu。
	contextMenu: null,
	// 扩展 easyui-tree 的自定义属性，表示是否启用右键菜单中的“展开当前、折叠当前、展开当前所有、折叠当前所有”菜单项的功能；
	// 该属性可以定义为以下类型：
	// Boolean 类型，表示是否启用这四个菜单项；
	// JSON-Object 类型，该 JSON-Object 可以包含如下属性：
	// expand: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“展开当前”菜单；
	// expandAll: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“展开当前所有”菜单；
	// collapse: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“折叠当前”菜单；
	// collapseAll: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“折叠当前所有”菜单；
	// submenu: 表示这四个菜单项是否以子菜单方式呈现，默认为 true；
	// 上面四个属性，如果参数的值为函数，则函数的签名为 function(e, node, tree, item, menu)。
	// 备注：当 enableContextMenu 属性设置为 true 时，该属性才有效。
	// 这四个菜单点击时，会自动触发 easyui-tree 的折叠/展开菜单项的相应事件。
	toggleMenu: true,
	// 扩展 easyui-tree 的自定义属性，表示是否启用右键菜单中的“上移、下移、上移一级、下移一级”菜单项的功能；
	// 备注：当 enableContextMenu 属性设置为 true 时，该属性才有效。
	// 该属性可以定义为以下类型：
	// Boolean 类型，表示是否启用这四个菜单项，默认为 false；
	// JSON-Object 类型，该 JSON-Object 可以包含如下属性：
	// up: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“上移”菜单；
	// upLevel: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“上移一级”菜单；
	// down: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“下移”菜单；
	// downLevel: 布尔类型的值，也可是一个返回布尔值的函数，表示是否显示“下移一级”菜单；
	// submenu: 表示这四个菜单项是否以子菜单方式呈现，默认为 true；
	// 上面四个属性，如果参数的值为函数，则函数的签名为 function(e, node, tree, item, menu)。
	// 这四个菜单点击时，会自动触发 easyui-tree 的 onDrop 事件。
	moveMenu: false,
	// 扩展 easyui-tree 的自定义属性，该属性表示在启用右键菜单的情况下，右键菜单项中是否显示 "显示 Tree 的 Option" 菜单项
	// Boolean 类型值；默认为 false。
	showOption: false,
	// 表示当执行远程请求获取数据时，被一并发送到服务器的查询参数，参考 easyui-datagrid 中的 queryParams 属性定义；
	// 这是一个 JSON-Object 类型参数对象，其中每一个属性的值可以是值类型，也可以是返回值的函数。
	queryParams: {},
	// 覆盖 easyui-tree 的原生属性 loader，以支持相应扩展功能。
	loader: loader,
	// 覆盖 easyui-tree 的原生属性 loadFilter，以支持相应扩展功能(支持平滑数据格式)。
	loadFilter: loadFilter,
	// 覆盖 easyui-tree 的原生事件 onExpand，以支持相应扩展功能。
	onExpand: onExpand
	};
	$.extend($.fn.tree.defaults, defaults);
	$.extend($.fn.tree.methods, methods);
	})(jQuery);