/** * 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);