| /* | |
| * JQuery zTree excheck 3.5.02 | |
| * http://zTree.me/ | |
| * | |
| * Copyright (c) 2010 Hunter.z | |
| * | |
| * Licensed same as jquery - MIT License | |
| * http://www.opensource.org/licenses/mit-license.php | |
| * | |
| * email: hunter.z@263.net | |
| * Date: 2013-01-28 | |
| */ | |
| (function($){ | |
| //default consts of excheck | |
| var _consts = { | |
| event: { | |
| CHECK: "ztree_check" | |
| }, | |
| id: { | |
| CHECK: "_check" | |
| }, | |
| checkbox: { | |
| STYLE: "checkbox", | |
| DEFAULT: "chk", | |
| DISABLED: "disable", | |
| FALSE: "false", | |
| TRUE: "true", | |
| FULL: "full", | |
| PART: "part", | |
| FOCUS: "focus" | |
| }, | |
| radio: { | |
| STYLE: "radio", | |
| TYPE_ALL: "all", | |
| TYPE_LEVEL: "level" | |
| } | |
| }, | |
| //default setting of excheck | |
| _setting = { | |
| check: { | |
| enable: false, | |
| autoCheckTrigger: false, | |
| chkStyle: _consts.checkbox.STYLE, | |
| nocheckInherit: false, | |
| chkDisabledInherit: false, | |
| radioType: _consts.radio.TYPE_LEVEL, | |
| chkboxType: { | |
| "Y": "ps", | |
| "N": "ps" | |
| } | |
| }, | |
| data: { | |
| key: { | |
| checked: "checked" | |
| } | |
| }, | |
| callback: { | |
| beforeCheck:null, | |
| onCheck:null | |
| } | |
| }, | |
| //default root of excheck | |
| _initRoot = function (setting) { | |
| var r = data.getRoot(setting); | |
| r.radioCheckedList = []; | |
| }, | |
| //default cache of excheck | |
| _initCache = function(treeId) {}, | |
| //default bind event of excheck | |
| _bindEvent = function(setting) { | |
| var o = setting.treeObj, | |
| c = consts.event; | |
| o.bind(c.CHECK, function (event, srcEvent, treeId, node) { | |
| tools.apply(setting.callback.onCheck, [!!srcEvent?srcEvent : event, treeId, node]); | |
| }); | |
| }, | |
| _unbindEvent = function(setting) { | |
| var o = setting.treeObj, | |
| c = consts.event; | |
| o.unbind(c.CHECK); | |
| }, | |
| //default event proxy of excheck | |
| _eventProxy = function(e) { | |
| var target = e.target, | |
| setting = data.getSetting(e.data.treeId), | |
| tId = "", node = null, | |
| nodeEventType = "", treeEventType = "", | |
| nodeEventCallback = null, treeEventCallback = null; | |
| if (tools.eqs(e.type, "mouseover")) { | |
| if (setting.check.enable && tools.eqs(target.tagName, "span") && target.getAttribute("treeNode"+ consts.id.CHECK) !== null) { | |
| tId = target.parentNode.id; | |
| nodeEventType = "mouseoverCheck"; | |
| } | |
| } else if (tools.eqs(e.type, "mouseout")) { | |
| if (setting.check.enable && tools.eqs(target.tagName, "span") && target.getAttribute("treeNode"+ consts.id.CHECK) !== null) { | |
| tId = target.parentNode.id; | |
| nodeEventType = "mouseoutCheck"; | |
| } | |
| } else if (tools.eqs(e.type, "click")) { | |
| if (setting.check.enable && tools.eqs(target.tagName, "span") && target.getAttribute("treeNode"+ consts.id.CHECK) !== null) { | |
| tId = target.parentNode.id; | |
| nodeEventType = "checkNode"; | |
| } | |
| } | |
| if (tId.length>0) { | |
| node = data.getNodeCache(setting, tId); | |
| switch (nodeEventType) { | |
| case "checkNode" : | |
| nodeEventCallback = _handler.onCheckNode; | |
| break; | |
| case "mouseoverCheck" : | |
| nodeEventCallback = _handler.onMouseoverCheck; | |
| break; | |
| case "mouseoutCheck" : | |
| nodeEventCallback = _handler.onMouseoutCheck; | |
| break; | |
| } | |
| } | |
| var proxyResult = { | |
| stop: false, | |
| node: node, | |
| nodeEventType: nodeEventType, | |
| nodeEventCallback: nodeEventCallback, | |
| treeEventType: treeEventType, | |
| treeEventCallback: treeEventCallback | |
| }; | |
| return proxyResult | |
| }, | |
| //default init node of excheck | |
| _initNode = function(setting, level, n, parentNode, isFirstNode, isLastNode, openFlag) { | |
| if (!n) return; | |
| var checkedKey = setting.data.key.checked; | |
| if (typeof n[checkedKey] == "string") n[checkedKey] = tools.eqs(n[checkedKey], "true"); | |
| n[checkedKey] = !!n[checkedKey]; | |
| n.checkedOld = n[checkedKey]; | |
| if (typeof n.nocheck == "string") n.nocheck = tools.eqs(n.nocheck, "true"); | |
| n.nocheck = !!n.nocheck || (setting.check.nocheckInherit && parentNode && !!parentNode.nocheck); | |
| if (typeof n.chkDisabled == "string") n.chkDisabled = tools.eqs(n.chkDisabled, "true"); | |
| n.chkDisabled = !!n.chkDisabled || (setting.check.chkDisabledInherit && parentNode && !!parentNode.chkDisabled); | |
| if (typeof n.halfCheck == "string") n.halfCheck = tools.eqs(n.halfCheck, "true"); | |
| n.halfCheck = !!n.halfCheck; | |
| n.check_Child_State = -1; | |
| n.check_Focus = false; | |
| n.getCheckStatus = function() {return data.getCheckStatus(setting, n);}; | |
| }, | |
| //add dom for check | |
| _afterA = function(setting, node, html) { | |
| var checkedKey = setting.data.key.checked; | |
| if (setting.check.enable) { | |
| data.makeChkFlag(setting, node); | |
| if (setting.check.chkStyle == consts.radio.STYLE && setting.check.radioType == consts.radio.TYPE_ALL && node[checkedKey] ) { | |
| var r = data.getRoot(setting); | |
| r.radioCheckedList.push(node); | |
| } | |
| html.push("<span ID='", node.tId, consts.id.CHECK, "' class='", view.makeChkClass(setting, node), "' treeNode", consts.id.CHECK, (node.nocheck === true?" style='display:none;'":""),"></span>"); | |
| } | |
| }, | |
| //update zTreeObj, add method of check | |
| _zTreeTools = function(setting, zTreeTools) { | |
| zTreeTools.checkNode = function(node, checked, checkTypeFlag, callbackFlag) { | |
| var checkedKey = this.setting.data.key.checked; | |
| if (node.chkDisabled === true) return; | |
| if (checked !== true && checked !== false) { | |
| checked = !node[checkedKey]; | |
| } | |
| callbackFlag = !!callbackFlag; | |
| if (node[checkedKey] === checked && !checkTypeFlag) { | |
| return; | |
| } else if (callbackFlag && tools.apply(this.setting.callback.beforeCheck, [this.setting.treeId, node], true) == false) { | |
| return; | |
| } | |
| if (tools.uCanDo(this.setting) && this.setting.check.enable && node.nocheck !== true) { | |
| node[checkedKey] = checked; | |
| var checkObj = $("#" + node.tId + consts.id.CHECK); | |
| if (checkTypeFlag || this.setting.check.chkStyle === consts.radio.STYLE) view.checkNodeRelation(this.setting, node); | |
| view.setChkClass(this.setting, checkObj, node); | |
| view.repairParentChkClassWithSelf(this.setting, node); | |
| if (callbackFlag) { | |
| setting.treeObj.trigger(consts.event.CHECK, [null, setting.treeId, node]); | |
| } | |
| } | |
| } | |
| zTreeTools.checkAllNodes = function(checked) { | |
| view.repairAllChk(this.setting, !!checked); | |
| } | |
| zTreeTools.getCheckedNodes = function(checked) { | |
| var childKey = this.setting.data.key.children; | |
| checked = (checked !== false); | |
| return data.getTreeCheckedNodes(this.setting, data.getRoot(setting)[childKey], checked); | |
| } | |
| zTreeTools.getChangeCheckedNodes = function() { | |
| var childKey = this.setting.data.key.children; | |
| return data.getTreeChangeCheckedNodes(this.setting, data.getRoot(setting)[childKey]); | |
| } | |
| zTreeTools.setChkDisabled = function(node, disabled, inheritParent, inheritChildren) { | |
| disabled = !!disabled; | |
| inheritParent = !!inheritParent; | |
| inheritChildren = !!inheritChildren; | |
| view.repairSonChkDisabled(this.setting, node, disabled, inheritChildren); | |
| view.repairParentChkDisabled(this.setting, node.getParentNode(), disabled, inheritParent); | |
| } | |
| var _updateNode = zTreeTools.updateNode; | |
| zTreeTools.updateNode = function(node, checkTypeFlag) { | |
| if (_updateNode) _updateNode.apply(zTreeTools, arguments); | |
| if (!node || !this.setting.check.enable) return; | |
| var nObj = $("#" + node.tId); | |
| if (nObj.get(0) && tools.uCanDo(this.setting)) { | |
| var checkObj = $("#" + node.tId + consts.id.CHECK); | |
| if (checkTypeFlag == true || this.setting.check.chkStyle === consts.radio.STYLE) view.checkNodeRelation(this.setting, node); | |
| view.setChkClass(this.setting, checkObj, node); | |
| view.repairParentChkClassWithSelf(this.setting, node); | |
| } | |
| } | |
| }, | |
| //method of operate data | |
| _data = { | |
| getRadioCheckedList: function(setting) { | |
| var checkedList = data.getRoot(setting).radioCheckedList; | |
| for (var i=0, j=checkedList.length; i<j; i++) { | |
| if(!data.getNodeCache(setting, checkedList[i].tId)) { | |
| checkedList.splice(i, 1); | |
| i--; j--; | |
| } | |
| } | |
| return checkedList; | |
| }, | |
| getCheckStatus: function(setting, node) { | |
| if (!setting.check.enable || node.nocheck || node.chkDisabled) return null; | |
| var checkedKey = setting.data.key.checked, | |
| r = { | |
| checked: node[checkedKey], | |
| half: node.halfCheck ? node.halfCheck : (setting.check.chkStyle == consts.radio.STYLE ? (node.check_Child_State === 2) : (node[checkedKey] ? (node.check_Child_State > -1 && node.check_Child_State < 2) : (node.check_Child_State > 0))) | |
| }; | |
| return r; | |
| }, | |
| getTreeCheckedNodes: function(setting, nodes, checked, results) { | |
| if (!nodes) return []; | |
| var childKey = setting.data.key.children, | |
| checkedKey = setting.data.key.checked, | |
| onlyOne = (checked && setting.check.chkStyle == consts.radio.STYLE && setting.check.radioType == consts.radio.TYPE_ALL); | |
| results = !results ? [] : results; | |
| for (var i = 0, l = nodes.length; i < l; i++) { | |
| if (nodes[i].nocheck !== true && nodes[i].chkDisabled !== true && nodes[i][checkedKey] == checked) { | |
| results.push(nodes[i]); | |
| if(onlyOne) { | |
| break; | |
| } | |
| } | |
| data.getTreeCheckedNodes(setting, nodes[i][childKey], checked, results); | |
| if(onlyOne && results.length > 0) { | |
| break; | |
| } | |
| } | |
| return results; | |
| }, | |
| getTreeChangeCheckedNodes: function(setting, nodes, results) { | |
| if (!nodes) return []; | |
| var childKey = setting.data.key.children, | |
| checkedKey = setting.data.key.checked; | |
| results = !results ? [] : results; | |
| for (var i = 0, l = nodes.length; i < l; i++) { | |
| if (nodes[i].nocheck !== true && nodes[i].chkDisabled !== true && nodes[i][checkedKey] != nodes[i].checkedOld) { | |
| results.push(nodes[i]); | |
| } | |
| data.getTreeChangeCheckedNodes(setting, nodes[i][childKey], results); | |
| } | |
| return results; | |
| }, | |
| makeChkFlag: function(setting, node) { | |
| if (!node) return; | |
| var childKey = setting.data.key.children, | |
| checkedKey = setting.data.key.checked, | |
| chkFlag = -1; | |
| if (node[childKey]) { | |
| for (var i = 0, l = node[childKey].length; i < l; i++) { | |
| var cNode = node[childKey][i]; | |
| var tmp = -1; | |
| if (setting.check.chkStyle == consts.radio.STYLE) { | |
| if (cNode.nocheck === true || cNode.chkDisabled === true) { | |
| tmp = cNode.check_Child_State; | |
| } else if (cNode.halfCheck === true) { | |
| tmp = 2; | |
| } else if (cNode[checkedKey]) { | |
| tmp = 2; | |
| } else { | |
| tmp = cNode.check_Child_State > 0 ? 2:0; | |
| } | |
| if (tmp == 2) { | |
| chkFlag = 2; break; | |
| } else if (tmp == 0){ | |
| chkFlag = 0; | |
| } | |
| } else if (setting.check.chkStyle == consts.checkbox.STYLE) { | |
| if (cNode.nocheck === true || cNode.chkDisabled === true) { | |
| tmp = cNode.check_Child_State; | |
| } else if (cNode.halfCheck === true) { | |
| tmp = 1; | |
| } else if (cNode[checkedKey] ) { | |
| tmp = (cNode.check_Child_State === -1 || cNode.check_Child_State === 2) ? 2 : 1; | |
| } else { | |
| tmp = (cNode.check_Child_State > 0) ? 1 : 0; | |
| } | |
| if (tmp === 1) { | |
| chkFlag = 1; break; | |
| } else if (tmp === 2 && chkFlag > -1 && i > 0 && tmp !== chkFlag) { | |
| chkFlag = 1; break; | |
| } else if (chkFlag === 2 && tmp > -1 && tmp < 2) { | |
| chkFlag = 1; break; | |
| } else if (tmp > -1) { | |
| chkFlag = tmp; | |
| } | |
| } | |
| } | |
| } | |
| node.check_Child_State = chkFlag; | |
| } | |
| }, | |
| //method of event proxy | |
| _event = { | |
| }, | |
| //method of event handler | |
| _handler = { | |
| onCheckNode: function (event, node) { | |
| if (node.chkDisabled === true) return false; | |
| var setting = data.getSetting(event.data.treeId), | |
| checkedKey = setting.data.key.checked; | |
| if (tools.apply(setting.callback.beforeCheck, [setting.treeId, node], true) == false) return true; | |
| node[checkedKey] = !node[checkedKey]; | |
| view.checkNodeRelation(setting, node); | |
| var checkObj = $("#" + node.tId + consts.id.CHECK); | |
| view.setChkClass(setting, checkObj, node); | |
| view.repairParentChkClassWithSelf(setting, node); | |
| setting.treeObj.trigger(consts.event.CHECK, [event, setting.treeId, node]); | |
| return true; | |
| }, | |
| onMouseoverCheck: function(event, node) { | |
| if (node.chkDisabled === true) return false; | |
| var setting = data.getSetting(event.data.treeId), | |
| checkObj = $("#" + node.tId + consts.id.CHECK); | |
| node.check_Focus = true; | |
| view.setChkClass(setting, checkObj, node); | |
| return true; | |
| }, | |
| onMouseoutCheck: function(event, node) { | |
| if (node.chkDisabled === true) return false; | |
| var setting = data.getSetting(event.data.treeId), | |
| checkObj = $("#" + node.tId + consts.id.CHECK); | |
| node.check_Focus = false; | |
| view.setChkClass(setting, checkObj, node); | |
| return true; | |
| } | |
| }, | |
| //method of tools for zTree | |
| _tools = { | |
| }, | |
| //method of operate ztree dom | |
| _view = { | |
| checkNodeRelation: function(setting, node) { | |
| var pNode, i, l, | |
| childKey = setting.data.key.children, | |
| checkedKey = setting.data.key.checked, | |
| r = consts.radio; | |
| if (setting.check.chkStyle == r.STYLE) { | |
| var checkedList = data.getRadioCheckedList(setting); | |
| if (node[checkedKey]) { | |
| if (setting.check.radioType == r.TYPE_ALL) { | |
| for (i = checkedList.length-1; i >= 0; i--) { | |
| pNode = checkedList[i]; | |
| pNode[checkedKey] = false; | |
| checkedList.splice(i, 1); | |
| view.setChkClass(setting, $("#" + pNode.tId + consts.id.CHECK), pNode); | |
| if (pNode.parentTId != node.parentTId) { | |
| view.repairParentChkClassWithSelf(setting, pNode); | |
| } | |
| } | |
| checkedList.push(node); | |
| } else { | |
| var parentNode = (node.parentTId) ? node.getParentNode() : data.getRoot(setting); | |
| for (i = 0, l = parentNode[childKey].length; i < l; i++) { | |
| pNode = parentNode[childKey][i]; | |
| if (pNode[checkedKey] && pNode != node) { | |
| pNode[checkedKey] = false; | |
| view.setChkClass(setting, $("#" + pNode.tId + consts.id.CHECK), pNode); | |
| } | |
| } | |
| } | |
| } else if (setting.check.radioType == r.TYPE_ALL) { | |
| for (i = 0, l = checkedList.length; i < l; i++) { | |
| if (node == checkedList[i]) { | |
| checkedList.splice(i, 1); | |
| break; | |
| } | |
| } | |
| } | |
| } else { | |
| if (node[checkedKey] && (!node[childKey] || node[childKey].length==0 || setting.check.chkboxType.Y.indexOf("s") > -1)) { | |
| view.setSonNodeCheckBox(setting, node, true); | |
| } | |
| if (!node[checkedKey] && (!node[childKey] || node[childKey].length==0 || setting.check.chkboxType.N.indexOf("s") > -1)) { | |
| view.setSonNodeCheckBox(setting, node, false); | |
| } | |
| if (node[checkedKey] && setting.check.chkboxType.Y.indexOf("p") > -1) { | |
| view.setParentNodeCheckBox(setting, node, true); | |
| } | |
| if (!node[checkedKey] && setting.check.chkboxType.N.indexOf("p") > -1) { | |
| view.setParentNodeCheckBox(setting, node, false); | |
| } | |
| } | |
| }, | |
| makeChkClass: function(setting, node) { | |
| var checkedKey = setting.data.key.checked, | |
| c = consts.checkbox, r = consts.radio, | |
| fullStyle = ""; | |
| if (node.chkDisabled === true) { | |
| fullStyle = c.DISABLED; | |
| } else if (node.halfCheck) { | |
| fullStyle = c.PART; | |
| } else if (setting.check.chkStyle == r.STYLE) { | |
| fullStyle = (node.check_Child_State < 1)? c.FULL:c.PART; | |
| } else { | |
| fullStyle = node[checkedKey] ? ((node.check_Child_State === 2 || node.check_Child_State === -1) ? c.FULL:c.PART) : ((node.check_Child_State < 1)? c.FULL:c.PART); | |
| } | |
| var chkName = setting.check.chkStyle + "_" + (node[checkedKey] ? c.TRUE : c.FALSE) + "_" + fullStyle; | |
| chkName = (node.check_Focus && node.chkDisabled !== true) ? chkName + "_" + c.FOCUS : chkName; | |
| return "bttn " + c.DEFAULT + " " + chkName; | |
| }, | |
| repairAllChk: function(setting, checked) { | |
| if (setting.check.enable && setting.check.chkStyle === consts.checkbox.STYLE) { | |
| var checkedKey = setting.data.key.checked, | |
| childKey = setting.data.key.children, | |
| root = data.getRoot(setting); | |
| for (var i = 0, l = root[childKey].length; i<l ; i++) { | |
| var node = root[childKey][i]; | |
| if (node.nocheck !== true && node.chkDisabled !== true) { | |
| node[checkedKey] = checked; | |
| } | |
| view.setSonNodeCheckBox(setting, node, checked); | |
| } | |
| } | |
| }, | |
| repairChkClass: function(setting, node) { | |
| if (!node) return; | |
| data.makeChkFlag(setting, node); | |
| if (node.nocheck !== true) { | |
| var checkObj = $("#" + node.tId + consts.id.CHECK); | |
| view.setChkClass(setting, checkObj, node); | |
| } | |
| }, | |
| repairParentChkClass: function(setting, node) { | |
| if (!node || !node.parentTId) return; | |
| var pNode = node.getParentNode(); | |
| view.repairChkClass(setting, pNode); | |
| view.repairParentChkClass(setting, pNode); | |
| }, | |
| repairParentChkClassWithSelf: function(setting, node) { | |
| if (!node) return; | |
| var childKey = setting.data.key.children; | |
| if (node[childKey] && node[childKey].length > 0) { | |
| view.repairParentChkClass(setting, node[childKey][0]); | |
| } else { | |
| view.repairParentChkClass(setting, node); | |
| } | |
| }, | |
| repairSonChkDisabled: function(setting, node, chkDisabled, inherit) { | |
| if (!node) return; | |
| var childKey = setting.data.key.children; | |
| if (node.chkDisabled != chkDisabled) { | |
| node.chkDisabled = chkDisabled; | |
| } | |
| view.repairChkClass(setting, node); | |
| if (node[childKey] && inherit) { | |
| for (var i = 0, l = node[childKey].length; i < l; i++) { | |
| var sNode = node[childKey][i]; | |
| view.repairSonChkDisabled(setting, sNode, chkDisabled, inherit); | |
| } | |
| } | |
| }, | |
| repairParentChkDisabled: function(setting, node, chkDisabled, inherit) { | |
| if (!node) return; | |
| if (node.chkDisabled != chkDisabled && inherit) { | |
| node.chkDisabled = chkDisabled; | |
| } | |
| view.repairChkClass(setting, node); | |
| view.repairParentChkDisabled(setting, node.getParentNode(), chkDisabled, inherit); | |
| }, | |
| setChkClass: function(setting, obj, node) { | |
| if (!obj) return; | |
| if (node.nocheck === true) { | |
| obj.hide(); | |
| } else { | |
| obj.show(); | |
| } | |
| obj.removeClass(); | |
| obj.addClass(view.makeChkClass(setting, node)); | |
| }, | |
| setParentNodeCheckBox: function(setting, node, value, srcNode) { | |
| var childKey = setting.data.key.children, | |
| checkedKey = setting.data.key.checked, | |
| checkObj = $("#" + node.tId + consts.id.CHECK); | |
| if (!srcNode) srcNode = node; | |
| data.makeChkFlag(setting, node); | |
| if (node.nocheck !== true && node.chkDisabled !== true) { | |
| node[checkedKey] = value; | |
| view.setChkClass(setting, checkObj, node); | |
| if (setting.check.autoCheckTrigger && node != srcNode) { | |
| setting.treeObj.trigger(consts.event.CHECK, [null, setting.treeId, node]); | |
| } | |
| } | |
| if (node.parentTId) { | |
| var pSign = true; | |
| if (!value) { | |
| var pNodes = node.getParentNode()[childKey]; | |
| for (var i = 0, l = pNodes.length; i < l; i++) { | |
| if ((pNodes[i].nocheck !== true && pNodes[i].chkDisabled !== true && pNodes[i][checkedKey]) | |
| || ((pNodes[i].nocheck === true || pNodes[i].chkDisabled === true) && pNodes[i].check_Child_State > 0)) { | |
| pSign = false; | |
| break; | |
| } | |
| } | |
| } | |
| if (pSign) { | |
| view.setParentNodeCheckBox(setting, node.getParentNode(), value, srcNode); | |
| } | |
| } | |
| }, | |
| setSonNodeCheckBox: function(setting, node, value, srcNode) { | |
| if (!node) return; | |
| var childKey = setting.data.key.children, | |
| checkedKey = setting.data.key.checked, | |
| checkObj = $("#" + node.tId + consts.id.CHECK); | |
| if (!srcNode) srcNode = node; | |
| var hasDisable = false; | |
| if (node[childKey]) { | |
| for (var i = 0, l = node[childKey].length; i < l && node.chkDisabled !== true; i++) { | |
| var sNode = node[childKey][i]; | |
| view.setSonNodeCheckBox(setting, sNode, value, srcNode); | |
| if (sNode.chkDisabled === true) hasDisable = true; | |
| } | |
| } | |
| if (node != data.getRoot(setting) && node.chkDisabled !== true) { | |
| if (hasDisable && node.nocheck !== true) { | |
| data.makeChkFlag(setting, node); | |
| } | |
| if (node.nocheck !== true && node.chkDisabled !== true) { | |
| node[checkedKey] = value; | |
| if (!hasDisable) node.check_Child_State = (node[childKey] && node[childKey].length > 0) ? (value ? 2 : 0) : -1; | |
| } else { | |
| node.check_Child_State = -1; | |
| } | |
| view.setChkClass(setting, checkObj, node); | |
| if (setting.check.autoCheckTrigger && node != srcNode && node.nocheck !== true && node.chkDisabled !== true) { | |
| setting.treeObj.trigger(consts.event.CHECK, [null, setting.treeId, node]); | |
| } | |
| } | |
| } | |
| }, | |
| _z = { | |
| tools: _tools, | |
| view: _view, | |
| event: _event, | |
| data: _data | |
| }; | |
| $.extend(true, $.fn.zTree.consts, _consts); | |
| $.extend(true, $.fn.zTree._z, _z); | |
| var zt = $.fn.zTree, | |
| tools = zt._z.tools, | |
| consts = zt.consts, | |
| view = zt._z.view, | |
| data = zt._z.data, | |
| event = zt._z.event; | |
| data.exSetting(_setting); | |
| data.addInitBind(_bindEvent); | |
| data.addInitUnBind(_unbindEvent); | |
| data.addInitCache(_initCache); | |
| data.addInitNode(_initNode); | |
| data.addInitProxy(_eventProxy); | |
| data.addInitRoot(_initRoot); | |
| data.addAfterA(_afterA); | |
| data.addZTreeTools(_zTreeTools); | |
| var _createNodes = view.createNodes; | |
| view.createNodes = function(setting, level, nodes, parentNode) { | |
| if (_createNodes) _createNodes.apply(view, arguments); | |
| if (!nodes) return; | |
| view.repairParentChkClassWithSelf(setting, parentNode); | |
| } | |
| var _removeNode = view.removeNode; | |
| view.removeNode = function(setting, node) { | |
| var parentNode = node.getParentNode(); | |
| if (_removeNode) _removeNode.apply(view, arguments); | |
| if (!node || !parentNode) return; | |
| view.repairChkClass(setting, parentNode); | |
| view.repairParentChkClass(setting, parentNode); | |
| } | |
| var _appendNodes = view.appendNodes; | |
| view.appendNodes = function(setting, level, nodes, parentNode, initFlag, openFlag) { | |
| var html = ""; | |
| if (_appendNodes) { | |
| html = _appendNodes.apply(view, arguments); | |
| } | |
| if (parentNode) { | |
| data.makeChkFlag(setting, parentNode); | |
| } | |
| return html; | |
| } | |
| })(jQuery); |