1 2/* 3 * JQuery zTree core v3.5.29 4 * http://treejs.cn/ 5 * 6 * Copyright (c) 2010 Hunter.z 7 * 8 * Licensed same as jquery - MIT License 9 * http://www.opensource.org/licenses/mit-license.php 10 * 11 * email: [email protected] 12 * Date: 2017-06-19 13 */ 14(function ($) { 15 var settings = {}, roots = {}, caches = {}, 16 //default consts of core 17 _consts = { 18 className: { 19 BUTTON: "button", 20 LEVEL: "level", 21 ICO_LOADING: "ico_loading", 22 SWITCH: "switch", 23 NAME: 'node_name' 24 }, 25 event: { 26 NODECREATED: "ztree_nodeCreated", 27 CLICK: "ztree_click", 28 EXPAND: "ztree_expand", 29 COLLAPSE: "ztree_collapse", 30 ASYNC_SUCCESS: "ztree_async_success", 31 ASYNC_ERROR: "ztree_async_error", 32 REMOVE: "ztree_remove", 33 SELECTED: "ztree_selected", 34 UNSELECTED: "ztree_unselected" 35 }, 36 id: { 37 A: "_a", 38 ICON: "_ico", 39 SPAN: "_span", 40 SWITCH: "_switch", 41 UL: "_ul" 42 }, 43 line: { 44 ROOT: "root", 45 ROOTS: "roots", 46 CENTER: "center", 47 BOTTOM: "bottom", 48 NOLINE: "noline", 49 LINE: "line" 50 }, 51 folder: { 52 OPEN: "open", 53 CLOSE: "close", 54 DOCU: "docu" 55 }, 56 node: { 57 CURSELECTED: "curSelectedNode" 58 } 59 }, 60 //default setting of core 61 _setting = { 62 treeId: "", 63 treeObj: null, 64 view: { 65 addDiyDom: null, 66 autoCancelSelected: true, 67 dblClickExpand: true, 68 expandSpeed: "fast", 69 fontCss: {}, 70 nameIsHTML: false, 71 selectedMulti: true, 72 showIcon: true, 73 showLine: true, 74 showTitle: true, 75 txtSelectedEnable: false 76 }, 77 data: { 78 key: { 79 children: "children", 80 name: "name", 81 title: "", 82 url: "url", 83 icon: "icon" 84 }, 85 simpleData: { 86 enable: false, 87 idKey: "id", 88 pIdKey: "pId", 89 rootPId: null 90 }, 91 keep: { 92 parent: false, 93 leaf: false 94 } 95 }, 96 async: { 97 enable: false, 98 contentType: "application/x-www-form-urlencoded", 99 type: "post", 100 dataType: "text", 101 url: "", 102 autoParam: [],
103 otherParam: [], 104 dataFilter: null 105 }, 106 callback: { 107 beforeAsync: null, 108 beforeClick: null, 109 beforeDblClick: null, 110 beforeRightClick: null, 111 beforeMouseDown: null, 112 beforeMouseUp: null, 113 beforeExpand: null, 114 beforeCollapse: null, 115 beforeRemove: null, 116 117 onAsyncError: null, 118 onAsyncSuccess: null, 119 onNodeCreated: null, 120 onClick: null, 121 onDblClick: null, 122 onRightClick: null, 123 onMouseDown: null, 124 onMouseUp: null, 125 onExpand: null, 126 onCollapse: null, 127 onRemove: null 128 } 129 }, 130 //default root of core 131 //zTree use root to save full data 132 _initRoot = function (setting) { 133 var r = data.getRoot(setting); 134 if (!r) { 135 r = {}; 136 data.setRoot(setting, r); 137 } 138 r[setting.data.key.children] = []; 139 r.expandTriggerFlag = false; 140 r.curSelectedList = [];
141 r.noSelection = true; 142 r.createdNodes = []; 143 r.zId = 0; 144 r._ver = (new Date()).getTime(); 145 }, 146 //default cache of core 147 _initCache = function (setting) { 148 var c = data.getCache(setting); 149 if (!c) { 150 c = {}; 151 data.setCache(setting, c); 152 } 153 c.nodes = []; 154 c.doms = []; 155 }, 156 //default bindEvent of core 157 _bindEvent = function (setting) { 158 var o = setting.treeObj, 159 c = consts.event; 160 o.bind(c.NODECREATED, function (event, treeId, node) { 161 tools.apply(setting.callback.onNodeCreated, [event, treeId, node]); 162 }); 163 164 o.bind(c.CLICK, function (event, srcEvent, treeId, node, clickFlag) { 165 tools.apply(setting.callback.onClick, [srcEvent, treeId, node, clickFlag]); 166 }); 167 168 o.bind(c.EXPAND, function (event, treeId, node) { 169 tools.apply(setting.callback.onExpand, [event, treeId, node]); 170 }); 171 172 o.bind(c.COLLAPSE, function (event, treeId, node) { 173 tools.apply(setting.callback.onCollapse, [event, treeId, node]); 174 }); 175 176 o.bind(c.ASYNC_SUCCESS, function (event, treeId, node, msg) { 177 tools.apply(setting.callback.onAsyncSuccess, [event, treeId, node, msg]); 178 }); 179 180 o.bind(c.ASYNC_ERROR, function (event, treeId, node, XMLHttpRequest, textStatus, errorThrown) { 181 tools.apply(setting.callback.onAsyncError, [event, treeId, node, XMLHttpRequest, textStatus, errorThrown]); 182 }); 183 184 o.bind(c.REMOVE, function (event, treeId, treeNode) { 185 tools.apply(setting.callback.onRemove, [event, treeId, treeNode]); 186 }); 187 188 o.bind(c.SELECTED, function (event, treeId, node) { 189 tools.apply(setting.callback.onSelected, [treeId, node]); 190 }); 191 o.bind(c.UNSELECTED, function (event, treeId, node) { 192 tools.apply(setting.callback.onUnSelected, [treeId, node]); 193 }); 194 }, 195 _unbindEvent = function (setting) { 196 var o = setting.treeObj, 197 c = consts.event; 198 o.unbind(c.NODECREATED) 199 .unbind(c.CLICK) 200 .unbind(c.EXPAND) 201 .unbind(c.COLLAPSE) 202 .unbind(c.ASYNC_SUCCESS) 203 .unbind(c.ASYNC_ERROR) 204 .unbind(c.REMOVE) 205 .unbind(c.SELECTED) 206 .unbind(c.UNSELECTED); 207 }, 208 //default event proxy of core 209 _eventProxy = function (event) { 210 var target = event.target, 211 setting = data.getSetting(event.data.treeId), 212 tId = "", node = null, 213 nodeEventType = "", treeEventType = "", 214 nodeEventCallback = null, treeEventCallback = null, 215 tmp = null; 216 217 if (tools.eqs(event.type, "mousedown")) { 218 treeEventType = "mousedown"; 219 } else if (tools.eqs(event.type, "mouseup")) { 220 treeEventType = "mouseup"; 221 } else if (tools.eqs(event.type, "contextmenu")) { 222 treeEventType = "contextmenu"; 223 } else if (tools.eqs(event.type, "click")) { 224 if (tools.eqs(target.tagName, "span") && target.getAttribute("treeNode" + consts.id.SWITCH) !== null) { 225 tId = tools.getNodeMainDom(target).id; 226 nodeEventType = "switchNode"; 227 } else { 228 tmp = tools.getMDom(setting, target, [{tagName: "a", attrName: "treeNode" + consts.id.A}]); 229 if (tmp) { 230 tId = tools.getNodeMainDom(tmp).id; 231 nodeEventType = "clickNode"; 232 } 233 } 234 } else if (tools.eqs(event.type, "dblclick")) { 235 treeEventType = "dblclick"; 236 tmp = tools.getMDom(setting, target, [{tagName: "a", attrName: "treeNode" + consts.id.A}]); 237 if (tmp) { 238 tId = tools.getNodeMainDom(tmp).id; 239 nodeEventType = "switchNode"; 240 } 241 } 242 if (treeEventType.length > 0 && tId.length == 0) { 243 tmp = tools.getMDom(setting, target, [{tagName: "a", attrName: "treeNode" + consts.id.A}]); 244 if (tmp) { 245 tId = tools.getNodeMainDom(tmp).id; 246 } 247 } 248 // event to node 249 if (tId.length > 0) { 250 node = data.getNodeCache(setting, tId); 251 switch (nodeEventType) { 252 case "switchNode" : 253 if (!node.isParent) { 254 nodeEventType = ""; 255 } else if (tools.eqs(event.type, "click") 256 || (tools.eqs(event.type, "dblclick") && tools.apply(setting.view.dblClickExpand, [setting.treeId, node], setting.view.dblClickExpand))) { 257 nodeEventCallback = handler.onSwitchNode; 258 } else { 259 nodeEventType = ""; 260 } 261 break; 262 case "clickNode" : 263 nodeEventCallback = handler.onClickNode; 264 break; 265 } 266 } 267 // event to zTree 268 switch (treeEventType) { 269 case "mousedown" : 270 treeEventCallback = handler.onZTreeMousedown; 271 break; 272 case "mouseup" : 273 treeEventCallback = handler.onZTreeMouseup; 274 break; 275 case "dblclick" : 276 treeEventCallback = handler.onZTreeDblclick; 277 break; 278 case "contextmenu" : 279 treeEventCallback = handler.onZTreeContextmenu; 280 break; 281 } 282 var proxyResult = { 283 stop: false, 284 node: node, 285 nodeEventType: nodeEventType, 286 nodeEventCallback: nodeEventCallback, 287 treeEventType: treeEventType, 288 treeEventCallback: treeEventCallback 289 }; 290 return proxyResult 291 }, 292 //default init node of core 293 _initNode = function (setting, level, n, parentNode, isFirstNode, isLastNode, openFlag) { 294 if (!n) return; 295 var r = data.getRoot(setting), 296 childKey = setting.data.key.children; 297 n.level = level; 298 n.tId = setting.treeId + "_" + (++r.zId); 299 n.parentTId = parentNode ? parentNode.tId : null; 300 n.open = (typeof n.open == "string") ? tools.eqs(n.open, "true") : !!n.open; 301 if (n[childKey] && n[childKey].length > 0) { 302 n.isParent = true; 303 n.zAsync = true; 304 } else { 305 n.isParent = (typeof n.isParent == "string") ? tools.eqs(n.isParent, "true") : !!n.isParent;
306 n.open = (n.isParent && !setting.async.enable) ? n.open : false; 307 n.zAsync = !n.isParent; 308 } 309 n.isFirstNode = isFirstNode; 310 n.isLastNode = isLastNode; 311 n.getParentNode = function () { 312 return data.getNodeCache(setting, n.parentTId); 313 }; 314 n.getPreNode = function () { 315 return data.getPreNode(setting, n); 316 }; 317 n.getNextNode = function () { 318 return data.getNextNode(setting, n); 319 }; 320 n.getIndex = function () { 321 return data.getNodeIndex(setting, n); 322 }; 323 n.getPath = function () { 324 return data.getNodePath(setting, n); 325 }; 326 n.isAjaxing = false; 327 data.fixPIdKeyValue(setting, n); 328 }, 329 _init = { 330 bind: [_bindEvent], 331 unbind: [_unbindEvent], 332 caches: [_initCache], 333 nodes: [_initNode], 334 proxys: [_eventProxy], 335 roots: [_initRoot], 336 beforeA: [], 337 afterA: [], 338 innerBeforeA: [], 339 innerAfterA: [], 340 zTreeTools: [] 341 }, 342 //method of operate data 343 data = { 344 addNodeCache: function (setting, node) { 345 data.getCache(setting).nodes[data.getNodeCacheId(node.tId)] = node; 346 }, 347 getNodeCacheId: function (tId) { 348 return tId.substring(tId.lastIndexOf("_") + 1); 349 }, 350 addAfterA: function (afterA) { 351 _init.afterA.push(afterA); 352 }, 353 addBeforeA: function (beforeA) { 354 _init.beforeA.push(beforeA); 355 }, 356 addInnerAfterA: function (innerAfterA) { 357 _init.innerAfterA.push(innerAfterA); 358 }, 359 addInnerBeforeA: function (innerBeforeA) { 360 _init.innerBeforeA.push(innerBeforeA); 361 }, 362 addInitBind: function (bindEvent) { 363 _init.bind.push(bindEvent); 364 }, 365 addInitUnBind: function (unbindEvent) { 366 _init.unbind.push(unbindEvent); 367 }, 368 addInitCache: function (initCache) { 369 _init.caches.push(initCache); 370 }, 371 addInitNode: function (initNode) { 372 _init.nodes.push(initNode); 373 }, 374 addInitProxy: function (initProxy, isFirst) { 375 if (!!isFirst) { 376 _init.proxys.splice(0, 0, initProxy); 377 } else { 378 _init.proxys.push(initProxy); 379 } 380 }, 381 addInitRoot: function (initRoot) { 382 _init.roots.push(initRoot); 383 }, 384 addNodesData: function (setting, parentNode, index, nodes) { 385 var childKey = setting.data.key.children, params; 386 if (!parentNode[childKey]) { 387 parentNode[childKey] = []; 388 index = -1; 389 } else if (index >= parentNode[childKey].length) { 390 index = -1; 391 } 392 393 if (parentNode[childKey].length > 0 && index === 0) { 394 parentNode[childKey][0].isFirstNode = false; 395 view.setNodeLineIcos(setting, parentNode[childKey][0]); 396 } else if (parentNode[childKey].length > 0 && index < 0) { 397 parentNode[childKey][parentNode[childKey].length - 1].isLastNode = false; 398 view.setNodeLineIcos(setting, parentNode[childKey][parentNode[childKey].length - 1]); 399 } 400 parentNode.isParent = true; 401 402 if (index < 0) { 403 parentNode[childKey] = parentNode[childKey].concat(nodes); 404 } else { 405 params = [index, 0].concat(nodes); 406 parentNode[childKey].splice.apply(parentNode[childKey], params); 407 } 408 }, 409 addSelectedNode: function (setting, node) { 410 var root = data.getRoot(setting); 411 if (!data.isSelectedNode(setting, node)) { 412 root.curSelectedList.push(node); 413 } 414 }, 415 addCreatedNode: function (setting, node) { 416 if (!!setting.callback.onNodeCreated || !!setting.view.addDiyDom) { 417 var root = data.getRoot(setting); 418 root.createdNodes.push(node); 419 } 420 }, 421 addZTreeTools: function (zTreeTools) { 422 _init.zTreeTools.push(zTreeTools); 423 }, 424 exSetting: function (s) { 425 $.extend(true, _setting, s); 426 }, 427 fixPIdKeyValue: function (setting, node) { 428 if (setting.data.simpleData.enable) { 429 node[setting.data.simpleData.pIdKey] = node.parentTId ? node.getParentNode()[setting.data.simpleData.idKey] : setting.data.simpleData.rootPId; 430 } 431 }, 432 getAfterA: function (setting, node, array) { 433 for (var i = 0, j = _init.afterA.length; i < j; i++) { 434 _init.afterA[i].apply(this, arguments); 435 } 436 }, 437 getBeforeA: function (setting, node, array) { 438 for (var i = 0, j = _init.beforeA.length; i < j; i++) { 439 _init.beforeA[i].apply(this, arguments); 440 } 441 }, 442 getInnerAfterA: function (setting, node, array) { 443 for (var i = 0, j = _init.innerAfterA.length; i < j; i++) { 444 _init.innerAfterA[i].apply(this, arguments); 445 } 446 }, 447 getInnerBeforeA: function (setting, node, array) { 448 for (var i = 0, j = _init.innerBeforeA.length; i < j; i++) { 449 _init.innerBeforeA[i].apply(this, arguments); 450 } 451 }, 452 getCache: function (setting) { 453 return caches[setting.treeId]; 454 }, 455 getNodeIndex: function (setting, node) { 456 if (!node) return null; 457 var childKey = setting.data.key.children, 458 p = node.parentTId ? node.getParentNode() : data.getRoot(setting); 459 for (var i = 0, l = p[childKey].length - 1; i <= l; i++) { 460 if (p[childKey][i] === node) { 461 return i; 462 } 463 } 464 return -1; 465 }, 466 getNextNode: function (setting, node) { 467 if (!node) return null; 468 var childKey = setting.data.key.children, 469 p = node.parentTId ? node.getParentNode() : data.getRoot(setting); 470 for (var i = 0, l = p[childKey].length - 1; i <= l; i++) { 471 if (p[childKey][i] === node) { 472 return (i == l ? null : p[childKey][i + 1]); 473 } 474 } 475 return null; 476 }, 477 getNodeByParam: function (setting, nodes, key, value) {
478 if (!nodes || !key) return null; 479 var childKey = setting.data.key.children; 480 for (var i = 0, l = nodes.length; i < l; i++) { 481 if (nodes[i][key] == value) { 482 return nodes[i]; 483 } 484 var tmp = data.getNodeByParam(setting, nodes[i][childKey], key, value); 485 if (tmp) return tmp; 486 } 487 return null; 488 }, 489 getNodeCache: function (setting, tId) { 490 if (!tId) return null; 491 var n = caches[setting.treeId].nodes[data.getNodeCacheId(tId)]; 492 return n ? n : null; 493 }, 494 getNodeName: function (setting, node) { 495 var nameKey = setting.data.key.name; 496 return "" + node[nameKey]; 497 }, 498 getNodePath: function (setting, node) { 499 if (!node) return null; 500 501 var path; 502 if (node.parentTId) { 503 path = node.getParentNode().getPath(); 504 } else { 505 path = []; 506 } 507 508 if (path) { 509 path.push(node); 510 } 511 512 return path; 513 }, 514 getNodeTitle: function (setting, node) { 515 var t = setting.data.key.title === "" ? setting.data.key.name : setting.data.key.title; 516 return "" + node[t]; 517 }, 518 getNodes: function (setting) { 519 return data.getRoot(setting)[setting.data.key.children]; 520 }, 521 getNodesByParam: function (setting, nodes, key, value) { 522 if (!nodes || !key) return []; 523 var childKey = setting.data.key.children, 524 result = []; 525 for (var i = 0, l = nodes.length; i < l; i++) { 526 if (nodes[i][key] == value) { 527 result.push(nodes[i]); 528 } 529 result = result.concat(data.getNodesByParam(setting, nodes[i][childKey], key, value)); 530 } 531 return result; 532 }, 533 getNodesByParamFuzzy: function (setting, nodes, key, value) { 534 if (!nodes || !key) return []; 535 var childKey = setting.data.key.children, 536 result = []; 537 value = value.toLowerCase(); 538 for (var i = 0, l = nodes.length; i < l; i++) { 539 if (typeof nodes[i][key] == "string" && nodes[i][key].toLowerCase().indexOf(value) > -1) { 540 result.push(nodes[i]); 541 } 542 result = result.concat(data.getNodesByParamFuzzy(setting, nodes[i][childKey], key, value)); 543 } 544 return result; 545 }, 546 getNodesByFilter: function (setting, nodes, filter, isSingle, invokeParam) { 547 if (!nodes) return (isSingle ? null : []); 548 var childKey = setting.data.key.children, 549 result = isSingle ? null : []; 550 for (var i = 0, l = nodes.length; i < l; i++) { 551 if (tools.apply(filter, [nodes[i], invokeParam], false)) { 552 if (isSingle) { 553 return nodes[i]; 554 } 555 result.push(nodes[i]); 556 } 557 var tmpResult = data.getNodesByFilter(setting, nodes[i][childKey], filter, isSingle, invokeParam); 558 if (isSingle && !!tmpResult) { 559 return tmpResult; 560 } 561 result = isSingle ? tmpResult : result.concat(tmpResult); 562 } 563 return result; 564 }, 565 getPreNode: function (setting, node) { 566 if (!node) return null; 567 var childKey = setting.data.key.children, 568 p = node.parentTId ? node.getParentNode() : data.getRoot(setting); 569 for (var i = 0, l = p[childKey].length; i < l; i++) { 570 if (p[childKey][i] === node) { 571 return (i == 0 ? null : p[childKey][i - 1]); 572 } 573 } 574 return null; 575 }, 576 getRoot: function (setting) { 577 return setting ? roots[setting.treeId] : null; 578 }, 579 getRoots: function () { 580 return roots; 581 }, 582 getSetting: function (treeId) { 583 return settings[treeId]; 584 }, 585 getSettings: function () { 586 return settings; 587 }, 588 getZTreeTools: function (treeId) { 589 var r = this.getRoot(this.getSetting(treeId)); 590 return r ? r.treeTools : null; 591 }, 592 initCache: function (setting) { 593 for (var i = 0, j = _init.caches.length; i < j; i++) { 594 _init.caches[i].apply(this, arguments); 595 } 596 }, 597 initNode: function (setting, level, node, parentNode, preNode, nextNode) { 598 for (var i = 0, j = _init.nodes.length; i < j; i++) { 599 _init.nodes[i].apply(this, arguments); 600 } 601 }, 602 initRoot: function (setting) { 603 for (var i = 0, j = _init.roots.length; i < j; i++) { 604 _init.roots[i].apply(this, arguments); 605 } 606 }, 607 isSelectedNode: function (setting, node) { 608 var root = data.getRoot(setting); 609 for (var i = 0, j = root.curSelectedList.length; i < j; i++) { 610 if (node === root.curSelectedList[i]) return true; 611 } 612 return false;
613 }, 614 removeNodeCache: function (setting, node) { 615 var childKey = setting.data.key.children; 616 if (node[childKey]) { 617 for (var i = 0, l = node[childKey].length; i < l; i++) { 618 data.removeNodeCache(setting, node[childKey][i]); 619 } 620 } 621 data.getCache(setting).nodes[data.getNodeCacheId(node.tId)] = null; 622 }, 623 removeSelectedNode: function (setting, node) { 624 var root = data.getRoot(setting); 625 for (var i = 0, j = root.curSelectedList.length; i < j; i++) { 626 if (node === root.curSelectedList[i] || !data.getNodeCache(setting, root.curSelectedList[i].tId)) { 627 root.curSelectedList.splice(i, 1); 628 setting.treeObj.trigger(consts.event.UNSELECTED, [setting.treeId, node]); 629 i--; 630 j--; 631 } 632 } 633 }, 634 setCache: function (setting, cache) { 635 caches[setting.treeId] = cache; 636 }, 637 setRoot: function (setting, root) { 638 roots[setting.treeId] = root; 639 }, 640 setZTreeTools: function (setting, zTreeTools) { 641 for (var i = 0, j = _init.zTreeTools.length; i < j; i++) { 642 _init.zTreeTools[i].apply(this, arguments); 643 } 644 }, 645 transformToArrayFormat: function (setting, nodes) { 646 if (!nodes) return []; 647 var childKey = setting.data.key.children, 648 r = []; 649 if (tools.isArray(nodes)) { 650 for (var i = 0, l = nodes.length; i < l; i++) { 651 r.push(nodes[i]); 652 if (nodes[i][childKey]) 653 r = r.concat(data.transformToArrayFormat(setting, nodes[i][childKey])); 654 } 655 } else { 656 r.push(nodes); 657 if (nodes[childKey]) 658 r = r.concat(data.transformToArrayFormat(setting, nodes[childKey])); 659 } 660 return r; 661 }, 662 transformTozTreeFormat: function (setting, sNodes) { 663 var i, l, 664 key = setting.data.simpleData.idKey, 665 parentKey = setting.data.simpleData.pIdKey, 666 childKey = setting.data.key.children; 667 if (!key || key == "" || !sNodes) return []; 668 669 if (tools.isArray(sNodes)) { 670 var r = []; 671 var tmpMap = {}; 672 for (i = 0, l = sNodes.length; i < l; i++) { 673 tmpMap[sNodes[i][key]] = sNodes[i]; 674 } 675 for (i = 0, l = sNodes.length; i < l; i++) { 676 if (tmpMap[sNodes[i][parentKey]] && sNodes[i][key] != sNodes[i][parentKey]) { 677 if (!tmpMap[sNodes[i][parentKey]][childKey]) 678 tmpMap[sNodes[i][parentKey]][childKey] = []; 679 tmpMap[sNodes[i][parentKey]][childKey].push(sNodes[i]); 680 } else { 681 r.push(sNodes[i]); 682 } 683 } 684 return r; 685 } else { 686 return [sNodes]; 687 } 688 } 689 }, 690 //method of event proxy 691 event = { 692 bindEvent: function (setting) { 693 for (var i = 0, j = _init.bind.length; i < j; i++) { 694 _init.bind[i].apply(this, arguments); 695 } 696 }, 697 unbindEvent: function (setting) { 698 for (var i = 0, j = _init.unbind.length; i < j; i++) { 699 _init.unbind[i].apply(this, arguments); 700 } 701 }, 702 bindTree: function (setting) { 703 var eventParam = { 704 treeId: setting.treeId 705 }, 706 o = setting.treeObj; 707 if (!setting.view.txtSelectedEnable) { 708 // for can't select text 709 o.bind('selectstart', handler.onSelectStart).css({ 710 "-moz-user-select": "-moz-none" 711 }); 712 } 713 o.bind('click', eventParam, event.proxy); 714 o.bind('dblclick', eventParam, event.proxy); 715 o.bind('mouseover', eventParam, event.proxy); 716 o.bind('mouseout', eventParam, event.proxy); 717 o.bind('mousedown', eventParam, event.proxy); 718 o.bind('mouseup', eventParam, event.proxy); 719 o.bind('contextmenu', eventParam, event.proxy); 720 }, 721 unbindTree: function (setting) { 722 var o = setting.treeObj; 723 o.unbind('selectstart', handler.onSelectStart) 724 .unbind('click', event.proxy) 725 .unbind('dblclick', event.proxy) 726 .unbind('mouseover', event.proxy) 727 .unbind('mouseout', event.proxy) 728 .unbind('mousedown', event.proxy) 729 .unbind('mouseup', event.proxy) 730 .unbind('contextmenu', event.proxy); 731 }, 732 doProxy: function (e) { 733 var results = []; 734 for (var i = 0, j = _init.proxys.length; i < j; i++) { 735 var proxyResult = _init.proxys[i].apply(this, arguments); 736 results.push(proxyResult); 737 if (proxyResult.stop) { 738 break; 739 } 740 } 741 return results; 742 }, 743 proxy: function (e) { 744 var setting = data.getSetting(e.data.treeId); 745 if (!tools.uCanDo(setting, e)) return true; 746 var results = event.doProxy(e), 747 r = true, x = false;
748 for (var i = 0, l = results.length; i < l; i++) { 749 var proxyResult = results[i]; 750 if (proxyResult.nodeEventCallback) { 751 x = true; 752 r = proxyResult.nodeEventCallback.apply(proxyResult, [e, proxyResult.node]) && r; 753 } 754 if (proxyResult.treeEventCallback) { 755 x = true; 756 r = proxyResult.treeEventCallback.apply(proxyResult, [e, proxyResult.node]) && r; 757 } 758 } 759 return r; 760 } 761 }, 762 //method of event handler 763 handler = { 764 onSwitchNode: function (event, node) { 765 var setting = data.getSetting(event.data.treeId); 766 if (node.open) { 767 if (tools.apply(setting.callback.beforeCollapse, [setting.treeId, node], true) == false) return true; 768 data.getRoot(setting).expandTriggerFlag = true; 769 view.switchNode(setting, node); 770 } else { 771 if (tools.apply(setting.callback.beforeExpand, [setting.treeId, node], true) == false) return true; 772 data.getRoot(setting).expandTriggerFlag = true; 773 view.switchNode(setting, node); 774 } 775 return true; 776 }, 777 onClickNode: function (event, node) { 778 var setting = data.getSetting(event.data.treeId), 779 clickFlag = ( (setting.view.autoCancelSelected && (event.ctrlKey || event.metaKey)) && data.isSelectedNode(setting, node)) ? 0 : (setting.view.autoCancelSelected && (event.ctrlKey || event.metaKey) && setting.view.selectedMulti) ? 2 : 1; 780 if (tools.apply(setting.callback.beforeClick, [setting.treeId, node, clickFlag], true) == false) return true; 781 if (clickFlag === 0) { 782 view.cancelPreSelectedNode(setting, node); 783 } else { 784 view.selectNode(setting, node, clickFlag === 2); 785 } 786 setting.treeObj.trigger(consts.event.CLICK, [event, setting.treeId, node, clickFlag]); 787 return true; 788 }, 789 onZTreeMousedown: function (event, node) { 790 var setting = data.getSetting(event.data.treeId); 791 if (tools.apply(setting.callback.beforeMouseDown, [setting.treeId, node], true)) { 792 tools.apply(setting.callback.onMouseDown, [event, setting.treeId, node]); 793 } 794 return true; 795 }, 796 onZTreeMouseup: function (event, node) { 797 var setting = data.getSetting(event.data.treeId); 798 if (tools.apply(setting.callback.beforeMouseUp, [setting.treeId, node], true)) { 799 tools.apply(setting.callback.onMouseUp, [event, setting.treeId, node]); 800 } 801 return true; 802 }, 803 onZTreeDblclick: function (event, node) { 804 var setting = data.getSetting(event.data.treeId); 805 if (tools.apply(setting.callback.beforeDblClick, [setting.treeId, node], true)) { 806 tools.apply(setting.callback.onDblClick, [event, setting.treeId, node]); 807 } 808 return true; 809 }, 810 onZTreeContextmenu: function (event, node) { 811 var setting = data.getSetting(event.data.treeId); 812 if (tools.apply(setting.callback.beforeRightClick, [setting.treeId, node], true)) { 813 tools.apply(setting.callback.onRightClick, [event, setting.treeId, node]); 814 } 815 return (typeof setting.callback.onRightClick) != "function"; 816 }, 817 onSelectStart: function (e) { 818 var n = e.originalEvent.srcElement.nodeName.toLowerCase(); 819 return (n === "input" || n === "textarea" ); 820 } 821 }, 822 //method of tools for zTree 823 tools = { 824 apply: function (fun, param, defaultValue) { 825 if ((typeof fun) == "function") { 826 return fun.apply(zt, param ? param : []); 827 } 828 return defaultValue; 829 }, 830 canAsync: function (setting, node) { 831 var childKey = setting.data.key.children; 832 return (setting.async.enable && node && node.isParent && !(node.zAsync || (node[childKey] && node[childKey].length > 0))); 833 }, 834 clone: function (obj) { 835 if (obj === null) return null; 836 var o = tools.isArray(obj) ? [] : {}; 837 for (var i in obj) { 838 o[i] = (obj[i] instanceof Date) ? new Date(obj[i].getTime()) : (typeof obj[i] === "object" ? tools.clone(obj[i]) : obj[i]); 839 } 840 return o; 841 }, 842 eqs: function (str1, str2) { 843 return str1.toLowerCase() === str2.toLowerCase(); 844 }, 845 isArray: function (arr) { 846 return Object.prototype.toString.apply(arr) === "[object Array]"; 847 }, 848 isElement: function (o) { 849 return ( 850 typeof HTMLElement === "object" ? o instanceof HTMLElement : //DOM2 851 o && typeof o === "object" && o !== null && o.nodeType === 1 && typeof o.nodeName === "string" 852 ); 853 }, 854 $: function (node, exp, setting) { 855 if (!!exp && typeof exp != "string") { 856 setting = exp; 857 exp = ""; 858 } 859 if (typeof node == "string") { 860 return $(node, setting ? setting.treeObj.get(0).ownerDocument : null); 861 } else { 862 return $("#" + node.tId + exp, setting ? setting.treeObj : null); 863 } 864 }, 865 getMDom: function (setting, curDom, targetExpr) { 866 if (!curDom) return null; 867 while (curDom && curDom.id !== setting.treeId) { 868 for (var i = 0, l = targetExpr.length; curDom.tagName && i < l; i++) { 869 if (tools.eqs(curDom.tagName, targetExpr[i].tagName) && curDom.getAttribute(targetExpr[i].attrName) !== null) { 870 return curDom; 871 } 872 } 873 curDom = curDom.parentNode; 874 } 875 return null; 876 }, 877 getNodeMainDom: function (target) { 878 return ($(target).parent("li").get(0) || $(target).parentsUntil("li").parent().get(0)); 879 }, 880 isChildOrSelf: function (dom, parentId) { 881 return ( $(dom).closest("#" + parentId).length > 0 ); 882 }, 883 uCanDo: function (setting, e) { 884 return true; 885 } 886 }, 887 //method of operate ztree dom 888 view = { 889 addNodes: function (setting, parentNode, index, newNodes, isSilent) { 890 if (setting.data.keep.leaf && parentNode && !parentNode.isParent) { 891 return; 892 } 893 if (!tools.isArray(newNodes)) { 894 newNodes = [newNodes]; 895 } 896 if (setting.data.simpleData.enable) {
897 newNodes = data.transformTozTreeFormat(setting, newNodes); 898 } 899 if (parentNode) { 900 var target_switchObj = $$(parentNode, consts.id.SWITCH, setting), 901 target_icoObj = $$(parentNode, consts.id.ICON, setting), 902 target_ulObj = $$(parentNode, consts.id.UL, setting); 903 904 if (!parentNode.open) { 905 view.replaceSwitchClass(parentNode, target_switchObj, consts.folder.CLOSE); 906 view.replaceIcoClass(parentNode, target_icoObj, consts.folder.CLOSE); 907 parentNode.open = false; 908 target_ulObj.css({ 909 "display": "none" 910 }); 911 } 912 913 data.addNodesData(setting, parentNode, index, newNodes); 914 view.createNodes(setting, parentNode.level + 1, newNodes, parentNode, index); 915 if (!isSilent) { 916 view.expandCollapseParentNode(setting, parentNode, true); 917 } 918 } else { 919 data.addNodesData(setting, data.getRoot(setting), index, newNodes); 920 view.createNodes(setting, 0, newNodes, null, index); 921 } 922 }, 923 appendNodes: function (setting, level, nodes, parentNode, index, initFlag, openFlag) { 924 if (!nodes) return []; 925 var html = [], 926 childKey = setting.data.key.children; 927 928 var tmpPNode = (parentNode) ? parentNode : data.getRoot(setting), 929 tmpPChild = tmpPNode[childKey], 930 isFirstNode, isLastNode; 931 932 if (!tmpPChild || index >= tmpPChild.length - nodes.length) { 933 index = -1; 934 } 935 936 for (var i = 0, l = nodes.length; i < l; i++) { 937 var node = nodes[i]; 938 if (initFlag) { 939 isFirstNode = ((index === 0 || tmpPChild.length == nodes.length) && (i == 0)); 940 isLastNode = (index < 0 && i == (nodes.length - 1)); 941 data.initNode(setting, level, node, parentNode, isFirstNode, isLastNode, openFlag); 942 data.addNodeCache(setting, node); 943 } 944 945 var childHtml = []; 946 if (node[childKey] && node[childKey].length > 0) { 947 //make child html first, because checkType 948 childHtml = view.appendNodes(setting, level + 1, node[childKey], node, -1, initFlag, openFlag && node.open); 949 } 950 if (openFlag) { 951 952 view.makeDOMNodeMainBefore(html, setting, node); 953 view.makeDOMNodeLine(html, setting, node); 954 data.getBeforeA(setting, node, html); 955 view.makeDOMNodeNameBefore(html, setting, node); 956 data.getInnerBeforeA(setting, node, html); 957 view.makeDOMNodeIcon(html, setting, node); 958 data.getInnerAfterA(setting, node, html); 959 view.makeDOMNodeNameAfter(html, setting, node); 960 data.getAfterA(setting, node, html); 961 if (node.isParent && node.open) { 962 view.makeUlHtml(setting, node, html, childHtml.join('')); 963 } 964 view.makeDOMNodeMainAfter(html, setting, node); 965 data.addCreatedNode(setting, node); 966 } 967 } 968 return html; 969 }, 970 appendParentULDom: function (setting, node) { 971 var html = [], 972 nObj = $$(node, setting); 973 if (!nObj.get(0) && !!node.parentTId) { 974 view.appendParentULDom(setting, node.getParentNode()); 975 nObj = $$(node, setting); 976 }
977 var ulObj = $$(node, consts.id.UL, setting); 978 if (ulObj.get(0)) { 979 ulObj.remove(); 980 } 981 var childKey = setting.data.key.children, 982 childHtml = view.appendNodes(setting, node.level + 1, node[childKey], node, -1, false, true); 983 view.makeUlHtml(setting, node, html, childHtml.join('')); 984 nObj.append(html.join('')); 985 }, 986 asyncNode: function (setting, node, isSilent, callback) { 987 var i, l; 988 if (node && !node.isParent) { 989 tools.apply(callback); 990 return false; 991 } else if (node && node.isAjaxing) { 992 return false; 993 } else if (tools.apply(setting.callback.beforeAsync, [setting.treeId, node], true) == false) { 994 tools.apply(callback); 995 return false; 996 } 997 if (node) { 998 node.isAjaxing = true; 999 var icoObj = $$(node, consts.id.ICON, setting); 1000 icoObj.attr({"style": "", "class": consts.className.BUTTON + " " + consts.className.ICO_LOADING}); 1001 } 1002 1003 var tmpParam = {}; 1004 for (i = 0, l = setting.async.autoParam.length; node && i < l; i++) { 1005 var pKey = setting.async.autoParam[i].split("="), spKey = pKey; 1006 if (pKey.length > 1) { 1007 spKey = pKey[1]; 1008 pKey = pKey[0]; 1009 } 1010 tmpParam[spKey] = node[pKey]; 1011 } 1012 if (tools.isArray(setting.async.otherParam)) { 1013 for (i = 0, l = setting.async.otherParam.length; i < l; i += 2) { 1014 tmpParam[setting.async.otherParam[i]] = setting.async.otherParam[i + 1]; 1015 } 1016 } else { 1017 for (var p in setting.async.otherParam) { 1018 tmpParam[p] = setting.async.otherParam[p]; 1019 } 1020 } 1021 1022 var _tmpV = data.getRoot(setting)._ver; 1023 $.ajax({ 1024 contentType: setting.async.contentType, 1025 cache: false, 1026 type: setting.async.type, 1027 url: tools.apply(setting.async.url, [setting.treeId, node], setting.async.url), 1028 data: setting.async.contentType.indexOf('application/json') > -1 ? JSON.stringify(tmpParam) : tmpParam, 1029 dataType: setting.async.dataType, 1030 success: function (msg) { 1031 if (_tmpV != data.getRoot(setting)._ver) { 1032 return; 1033 } 1034 var newNodes = []; 1035 try { 1036 if (!msg || msg.length == 0) { 1037 newNodes = []; 1038 } else if (typeof msg == "string") { 1039 newNodes = eval("(" + msg + ")"); 1040 } else { 1041 newNodes = msg; 1042 } 1043 } catch (err) { 1044 newNodes = msg; 1045 } 1046 1047 if (node) { 1048 node.isAjaxing = null; 1049 node.zAsync = true; 1050 } 1051 view.setNodeLineIcos(setting, node); 1052 if (newNodes && newNodes !== "") { 1053 newNodes = tools.apply(setting.async.dataFilter, [setting.treeId, node, newNodes], newNodes); 1054 view.addNodes(setting, node, -1, !!newNodes ? tools.clone(newNodes) : [], !!isSilent); 1055 } else { 1056 view.addNodes(setting, node, -1, [], !!isSilent); 1057 } 1058 setting.treeObj.trigger(consts.event.ASYNC_SUCCESS, [setting.treeId, node, msg]); 1059 tools.apply(callback); 1060 }, 1061 error: function (XMLHttpRequest, textStatus, errorThrown) { 1062 if (_tmpV != data.getRoot(setting)._ver) { 1063 return; 1064 } 1065 if (node) node.isAjaxing = null; 1066 view.setNodeLineIcos(setting, node); 1067 setting.treeObj.trigger(consts.event.ASYNC_ERROR, [setting.treeId, node, XMLHttpRequest, textStatus, errorThrown]); 1068 } 1069 }); 1070 return true; 1071 }, 1072 cancelPreSelectedNode: function (setting, node, excludeNode) { 1073 var list = data.getRoot(setting).curSelectedList, 1074 i, n; 1075 for (i = list.length - 1; i >= 0; i--) { 1076 n = list[i]; 1077 if (node === n || (!node && (!excludeNode || excludeNode !== n))) { 1078 $$(n, consts.id.A, setting).removeClass(consts.node.CURSELECTED); 1079 if (node) { 1080 data.removeSelectedNode(setting, node); 1081 break; 1082 } else { 1083 list.splice(i, 1); 1084 setting.treeObj.trigger(consts.event.UNSELECTED, [setting.treeId, n]); 1085 } 1086 } 1087 } 1088 }, 1089 createNodeCallback: function (setting) { 1090 if (!!setting.callback.onNodeCreated || !!setting.view.addDiyDom) { 1091 var root = data.getRoot(setting); 1092 while (root.createdNodes.length > 0) { 1093 var node = root.createdNodes.shift(); 1094 tools.apply(setting.view.addDiyDom, [setting.treeId, node]); 1095 if (!!setting.callback.onNodeCreated) { 1096 setting.treeObj.trigger(consts.event.NODECREATED, [setting.treeId, node]); 1097 } 1098 } 1099 } 1100 }, 1101 createNodes: function (setting, level, nodes, parentNode, index) { 1102 if (!nodes || nodes.length == 0) return; 1103 var root = data.getRoot(setting), 1104 childKey = setting.data.key.children, 1105 openFlag = !parentNode || parentNode.open || !!$$(parentNode[childKey][0], setting).get(0); 1106 root.createdNodes = []; 1107 var zTreeHtml = view.appendNodes(setting, level, nodes, parentNode, index, true, openFlag), 1108 parentObj, nextObj; 1109 1110 if (!parentNode) { 1111 parentObj = setting.treeObj; 1112 //setting.treeObj.append(zTreeHtml.join('')); 1113 } else {
1114 var ulObj = $$(parentNode, consts.id.UL, setting); 1115 if (ulObj.get(0)) { 1116 parentObj = ulObj; 1117 //ulObj.append(zTreeHtml.join('')); 1118 } 1119 } 1120 if (parentObj) { 1121 if (index >= 0) { 1122 nextObj = parentObj.children()[index]; 1123 } 1124 if (index >= 0 && nextObj) { 1125 $(nextObj).before(zTreeHtml.join('')); 1126 } else { 1127 parentObj.append(zTreeHtml.join('')); 1128 } 1129 } 1130 1131 view.createNodeCallback(setting); 1132 }, 1133 destroy: function (setting) { 1134 if (!setting) return; 1135 data.initCache(setting); 1136 data.initRoot(setting); 1137 event.unbindTree(setting); 1138 event.unbindEvent(setting); 1139 setting.treeObj.empty(); 1140 delete settings[setting.treeId]; 1141 }, 1142 expandCollapseNode: function (setting, node, expandFlag, animateFlag, callback) { 1143 var root = data.getRoot(setting), 1144 childKey = setting.data.key.children; 1145 var tmpCb, _callback; 1146 if (!node) { 1147 tools.apply(callback, []); 1148 return; 1149 } 1150 if (root.expandTriggerFlag) { 1151 _callback = callback; 1152 tmpCb = function () { 1153 if (_callback) _callback(); 1154 if (node.open) { 1155 setting.treeObj.trigger(consts.event.EXPAND, [setting.treeId, node]); 1156 } else { 1157 setting.treeObj.trigger(consts.event.COLLAPSE, [setting.treeId, node]); 1158 } 1159 }; 1160 callback = tmpCb; 1161 root.expandTriggerFlag = false; 1162 } 1163 if (!node.open && node.isParent && ((!$$(node, consts.id.UL, setting).get(0)) || (node[childKey] && node[childKey].length > 0 && !$$(node[childKey][0], setting).get(0)))) { 1164 view.appendParentULDom(setting, node); 1165 view.createNodeCallback(setting); 1166 } 1167 if (node.open == expandFlag) { 1168 tools.apply(callback, []); 1169 return; 1170 } 1171 var ulObj = $$(node, consts.id.UL, setting), 1172 switchObj = $$(node, consts.id.SWITCH, setting), 1173 icoObj = $$(node, consts.id.ICON, setting); 1174 1175 if (node.isParent) { 1176 node.open = !node.open; 1177 if (node.iconOpen && node.iconClose) { 1178 icoObj.attr("style", view.makeNodeIcoStyle(setting, node)); 1179 } 1180 1181 if (node.open) { 1182 view.replaceSwitchClass(node, switchObj, consts.folder.OPEN); 1183 view.replaceIcoClass(node, icoObj, consts.folder.OPEN); 1184 if (animateFlag == false || setting.view.expandSpeed == "") { 1185 ulObj.show(); 1186 tools.apply(callback, []); 1187 } else { 1188 if (node[childKey] && node[childKey].length > 0) { 1189 ulObj.slideDown(setting.view.expandSpeed, callback); 1190 } else { 1191 ulObj.show(); 1192 tools.apply(callback, []); 1193 } 1194 } 1195 } else { 1196 view.replaceSwitchClass(node, switchObj, consts.folder.CLOSE); 1197 view.replaceIcoClass(node, icoObj, consts.folder.CLOSE); 1198 if (animateFlag == false || setting.view.expandSpeed == "" || !(node[childKey] && node[childKey].length > 0)) { 1199 ulObj.hide(); 1200 tools.apply(callback, []); 1201 } else { 1202 ulObj.slideUp(setting.view.expandSpeed, callback); 1203 } 1204 } 1205 } else { 1206 tools.apply(callback, []); 1207 } 1208 }, 1209 expandCollapseParentNode: function (setting, node, expandFlag, animateFlag, callback) { 1210 if (!node) return; 1211 if (!node.parentTId) { 1212 view.expandCollapseNode(setting, node, expandFlag, animateFlag, callback); 1213 return; 1214 } else { 1215 view.expandCollapseNode(setting, node, expandFlag, animateFlag); 1216 } 1217 if (node.parentTId) { 1218 view.expandCollapseParentNode(setting, node.getParentNode(), expandFlag, animateFlag, callback); 1219 } 1220 }, 1221 expandCollapseSonNode: function (setting, node, expandFlag, animateFlag, callback) { 1222 var root = data.getRoot(setting), 1223 childKey = setting.data.key.children, 1224 treeNodes = (node) ? node[childKey] : root[childKey], 1225 selfAnimateSign = (node) ? false : animateFlag, 1226 expandTriggerFlag = data.getRoot(setting).expandTriggerFlag; 1227 data.getRoot(setting).expandTriggerFlag = false;
1228 if (treeNodes) { 1229 for (var i = 0, l = treeNodes.length; i < l; i++) { 1230 if (treeNodes[i]) view.expandCollapseSonNode(setting, treeNodes[i], expandFlag, selfAnimateSign); 1231 } 1232 } 1233 data.getRoot(setting).expandTriggerFlag = expandTriggerFlag; 1234 view.expandCollapseNode(setting, node, expandFlag, animateFlag, callback); 1235 }, 1236 isSelectedNode: function (setting, node) { 1237 if (!node) { 1238 return false; 1239 } 1240 var list = data.getRoot(setting).curSelectedList, 1241 i; 1242 for (i = list.length - 1; i >= 0; i--) { 1243 if (node === list[i]) { 1244 return true; 1245 } 1246 } 1247 return false; 1248 }, 1249 makeDOMNodeIcon: function (html, setting, node) { 1250 var nameStr = data.getNodeName(setting, node), 1251 name = setting.view.nameIsHTML ? nameStr : nameStr.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>'); 1252 html.push("<span id='", node.tId, consts.id.ICON, 1253 "' title='' treeNode", consts.id.ICON, " class='", view.makeNodeIcoClass(setting, node), 1254 "' style='", view.makeNodeIcoStyle(setting, node), "'></span><span id='", node.tId, consts.id.SPAN, 1255 "' class='", consts.className.NAME, 1256 "'>", name, "</span>"); 1257 }, 1258 makeDOMNodeLine: function (html, setting, node) { 1259 html.push("<span id='", node.tId, consts.id.SWITCH, "' title='' class='", view.makeNodeLineClass(setting, node), "' treeNode", consts.id.SWITCH, "></span>"); 1260 }, 1261 makeDOMNodeMainAfter: function (html, setting, node) { 1262 html.push("</li>"); 1263 }, 1264 makeDOMNodeMainBefore: function (html, setting, node) { 1265 html.push("<li id='", node.tId, "' class='", consts.className.LEVEL, node.level, "' tabindex='0' hidefocus='true' treenode>"); 1266 }, 1267 makeDOMNodeNameAfter: function (html, setting, node) { 1268 html.push("</a>"); 1269 }, 1270 makeDOMNodeNameBefore: function (html, setting, node) { 1271 var title = data.getNodeTitle(setting, node), 1272 url = view.makeNodeUrl(setting, node), 1273 fontcss = view.makeNodeFontCss(setting, node), 1274 fontStyle = []; 1275 for (var f in fontcss) { 1276 fontStyle.push(f, ":", fontcss[f], ";"); 1277 } 1278 html.push("<a id='", node.tId, consts.id.A, "' class='", consts.className.LEVEL, node.level, "' treeNode", consts.id.A, " onclick=\"", (node.click || ''), 1279 "\" ", ((url != null && url.length > 0) ? "href='" + url + "'" : ""), " target='", view.makeNodeTarget(node), "' style='", fontStyle.join(''), 1280 "'"); 1281 if (tools.apply(setting.view.showTitle, [setting.treeId, node], setting.view.showTitle) && title) { 1282 html.push("title='", title.replace(/'/g, "'").replace(/</g, '<').replace(/>/g, '>'), "'"); 1283 } 1284 html.push(">"); 1285 }, 1286 makeNodeFontCss: function (setting, node) { 1287 var fontCss = tools.apply(setting.view.fontCss, [setting.treeId, node], setting.view.fontCss); 1288 return (fontCss && ((typeof fontCss) != "function")) ? fontCss : {}; 1289 }, 1290 makeNodeIcoClass: function (setting, node) { 1291 var icoCss = ["ico"]; 1292 if (!node.isAjaxing) { 1293 icoCss[0] = (node.iconSkin ? node.iconSkin + "_" : "") + icoCss[0]; 1294 if (node.isParent) { 1295 icoCss.push(node.open ? consts.folder.OPEN : consts.folder.CLOSE); 1296 } else { 1297 icoCss.push(consts.folder.DOCU); 1298 } 1299 } 1300 return consts.className.BUTTON + " " + icoCss.join('_'); 1301 }, 1302 makeNodeIcoStyle: function (setting, node) { 1303 var icoStyle = []; 1304 if (!node.isAjaxing) { 1305 var icon = (node.isParent && node.iconOpen && node.iconClose) ? (node.open ? node.iconOpen : node.iconClose) : node[setting.data.key.icon]; 1306 if (icon) icoStyle.push("background:url(", icon, ") 0 0 no-repeat;"); 1307 if (setting.view.showIcon == false || !tools.apply(setting.view.showIcon, [setting.treeId, node], true)) { 1308 icoStyle.push("width:0px;height:0px;"); 1309 } 1310 } 1311 return icoStyle.join(''); 1312 }, 1313 makeNodeLineClass: function (setting, node) { 1314 var lineClass = []; 1315 if (setting.view.showLine) { 1316 if (node.level == 0 && node.isFirstNode && node.isLastNode) { 1317 lineClass.push(consts.line.ROOT); 1318 } else if (node.level == 0 && node.isFirstNode) { 1319 lineClass.push(consts.line.ROOTS); 1320 } else if (node.isLastNode) { 1321 lineClass.push(consts.line.BOTTOM); 1322 } else { 1323 lineClass.push(consts.line.CENTER); 1324 } 1325 } else { 1326 lineClass.push(consts.line.NOLINE); 1327 } 1328 if (node.isParent) { 1329 lineClass.push(node.open ? consts.folder.OPEN : consts.folder.CLOSE); 1330 } else { 1331 lineClass.push(consts.folder.DOCU); 1332 } 1333 return view.makeNodeLineClassEx(node) + lineClass.join('_'); 1334 }, 1335 makeNodeLineClassEx: function (node) { 1336 return consts.className.BUTTON + " " + consts.className.LEVEL + node.level + " " + consts.className.SWITCH + " "; 1337 }, 1338 makeNodeTarget: function (node) { 1339 return (node.target || "_blank"); 1340 }, 1341 makeNodeUrl: function (setting, node) { 1342 var urlKey = setting.data.key.url; 1343 return node[urlKey] ? node[urlKey] : null; 1344 }, 1345 makeUlHtml: function (setting, node, html, content) { 1346 html.push("<ul id='", node.tId, consts.id.UL, "' class='", consts.className.LEVEL, node.level, " ", view.makeUlLineClass(setting, node), "' style='display:", (node.open ? "block" : "none"), "'>"); 1347 html.push(content); 1348 html.push("</ul>"); 1349 }, 1350 makeUlLineClass: function (setting, node) { 1351 return ((setting.view.showLine && !node.isLastNode) ? consts.line.LINE : ""); 1352 }, 1353 removeChildNodes: function (setting, node) { 1354 if (!node) return; 1355 var childKey = setting.data.key.children, 1356 nodes = node[childKey];
1357 if (!nodes) return; 1358 1359 for (var i = 0, l = nodes.length; i < l; i++) { 1360 data.removeNodeCache(setting, nodes[i]); 1361 } 1362 data.removeSelectedNode(setting); 1363 delete node[childKey]; 1364 1365 if (!setting.data.keep.parent) { 1366 node.isParent = false; 1367 node.open = false; 1368 var tmp_switchObj = $$(node, consts.id.SWITCH, setting), 1369 tmp_icoObj = $$(node, consts.id.ICON, setting); 1370 view.replaceSwitchClass(node, tmp_switchObj, consts.folder.DOCU); 1371 view.replaceIcoClass(node, tmp_icoObj, consts.folder.DOCU); 1372 $$(node, consts.id.UL, setting).remove(); 1373 } else { 1374 $$(node, consts.id.UL, setting).empty(); 1375 } 1376 }, 1377 scrollIntoView: function (dom) { 1378 if (!dom) { 1379 return; 1380 } 1381 // code src: http://jsfiddle.net/08u6cxwj/ 1382 if (!Element.prototype.scrollIntoViewIfNeeded) { 1383 Element.prototype.scrollIntoViewIfNeeded = function (centerIfNeeded) { 1384 function withinBounds(value, min, max, extent) { 1385 if (false === centerIfNeeded || max <= value + extent && value <= min + extent) { 1386 return Math.min(max, Math.max(min, value)); 1387 } else { 1388 return (min + max) / 2; 1389 } 1390 } 1391 1392 function makeArea(left, top, width, height) { 1393 return { 1394 "left": left, "top": top, "width": width, "he
1394ight": height 1395 , "right": left + width, "bottom": top + height 1396 , "translate": function (x, y) { 1397 return makeArea(x + left, y + top, width, height); 1398 } 1399 , "relativeFromTo": function (lhs, rhs) { 1400 var newLeft = left, newTop = top; 1401 lhs = lhs.offsetParent; 1402 rhs = rhs.offsetParent; 1403 if (lhs === rhs) { 1404 return area; 1405 } 1406 for (; lhs; lhs = lhs.offsetParent) { 1407 newLeft += lhs.offsetLeft + lhs.clientLeft; 1408 newTop += lhs.offsetTop + lhs.clientTop; 1409 } 1410 for (; rhs; rhs = rhs.offsetParent) { 1411 newLeft -= rhs.offsetLeft + rhs.clientLeft; 1412 newTop -= rhs.offsetTop + rhs.clientTop; 1413 } 1414 return makeArea(newLeft, newTop, width, height); 1415 } 1416 }; 1417 } 1418 1419 var parent, elem = this, area = makeArea( 1420 this.offsetLeft, this.offsetTop, 1421 this.offsetWidth, this.offsetHeight); 1422 while (tools.isElement(parent = elem.parentNode)) { 1423 var clientLeft = parent.offsetLeft + parent.clientLeft; 1424 var clientTop = parent.offsetTop + parent.clientTop; 1425 1426 // Make area relative to parent's client area. 1427 area = area.relativeFromTo(elem, parent).translate(-clientLeft, -clientTop); 1428 1429 parent.scrollLeft = withinBounds( 1430 parent.scrollLeft, 1431 area.right - parent.clientWidth, area.left, 1432 parent.clientWidth); 1433 1434 parent.scrollTop = withinBounds( 1435 parent.scrollTop, 1436 area.bottom - parent.clientHeight, area.top, 1437 parent.clientHeight); 1438 1439 // Determine actual scroll amount by reading back scroll properties. 1440 area = area.translate(clientLeft - parent.scrollLeft, 1441 clientTop - parent.scrollTop); 1442 elem = parent; 1443 } 1444 }; 1445 } 1446 dom.scrollIntoViewIfNeeded(); 1447 }, 1448 setFirstNode: function (setting, parentNode) { 1449 var childKey = setting.data.key.children, childLength = parentNode[childKey].length; 1450 if (childLength > 0) { 1451 parentNode[childKey][0].isFirstNode = true; 1452 } 1453 }, 1454 setLastNode: function (setting, parentNode) { 1455 var childKey = setting.data.key.children, childLength = parentNode[childKey].length; 1456 if (childLength > 0) { 1457 parentNode[childKey][childLength - 1].isLastNode = true; 1458 } 1459 }, 1460 removeNode: function (setting, node) { 1461 var root = data.getRoot(setting), 1462 childKey = setting.data.key.children, 1463 parentNode = (node.parentTId) ? node.getParentNode() : root; 1464 1465 node.isFirstNode = false; 1466 node.isLastNode = false; 1467 node.getPreNode = function () { 1468 return null; 1469 }; 1470 node.getNextNode = function () { 1471 return null; 1472 }; 1473 1474 if (!data.getNodeCache(setting, node.tId)) { 1475 return; 1476 } 1477 1478 $$(node, setting).remove(); 1479 data.removeNodeCache(setting, node); 1480 data.removeSelectedNode(setting, node); 1481 1482 for (var i = 0, l = parentNode[childKey].length; i < l; i++) { 1483 if (parentNode[childKey][i].tId == node.tId) { 1484 parentNode[childKey].splice(i, 1); 1485 break; 1486 } 1487 } 1488 view.setFirstNode(setting, parentNode); 1489 view.setLastNode(setting, parentNode); 1490 1491 var tmp_ulObj, tmp_switchObj, tmp_icoObj, 1492 childLength = parentNode[childKey].length; 1493 1494 //repair nodes old parent 1495 if (!setting.data.keep.parent && childLength == 0) { 1496 //old parentNode has no child nodes 1497 parentNode.isParent = false;
1498 parentNode.open = false; 1499 tmp_ulObj = $$(parentNode, consts.id.UL, setting); 1500 tmp_switchObj = $$(parentNode, consts.id.SWITCH, setting); 1501 tmp_icoObj = $$(parentNode, consts.id.ICON, setting); 1502 view.replaceSwitchClass(parentNode, tmp_switchObj, consts.folder.DOCU); 1503 view.replaceIcoClass(parentNode, tmp_icoObj, consts.folder.DOCU); 1504 tmp_ulObj.css("display", "none"); 1505 1506 } else if (setting.view.showLine && childLength > 0) { 1507 //old parentNode has child nodes 1508 var newLast = parentNode[childKey][childLength - 1]; 1509 tmp_ulObj = $$(newLast, consts.id.UL, setting); 1510 tmp_switchObj = $$(newLast, consts.id.SWITCH, setting); 1511 tmp_icoObj = $$(newLast, consts.id.ICON, setting); 1512 if (parentNode == root) { 1513 if (parentNode[childKey].length == 1) { 1514 //node was root, and ztree has only one root after move node 1515 view.replaceSwitchClass(newLast, tmp_switchObj, consts.line.ROOT); 1516 } else { 1517 var tmp_first_switchObj = $$(parentNode[childKey][0], consts.id.SWITCH, setting); 1518 view.replaceSwitchClass(parentNode[childKey][0], tmp_first_switchObj, consts.line.ROOTS); 1519 view.replaceSwitchClass(newLast, tmp_switchObj, consts.line.BOTTOM); 1520 } 1521 } else { 1522 view.replaceSwitchClass(newLast, tmp_switchObj, consts.line.BOTTOM); 1523 } 1524 tmp_ulObj.removeClass(consts.line.LINE); 1525 } 1526 }, 1527 replaceIcoClass: function (node, obj, newName) { 1528 if (!obj || node.isAjaxing) return; 1529 var tmpName = obj.attr("class"); 1530 if (tmpName == undefined) return; 1531 var tmpList = tmpName.split("_"); 1532 switch (newName) { 1533 case consts.folder.OPEN: 1534 case consts.folder.CLOSE: 1535 case consts.folder.DOCU: 1536 tmpList[tmpList.length - 1] = newName; 1537 break; 1538 } 1539 obj.attr("class", tmpList.join("_")); 1540 }, 1541 replaceSwitchClass: function (node, obj, newName) { 1542 if (!obj) return; 1543 var tmpName = obj.attr("class"); 1544 if (tmpName == undefined) return; 1545 var tmpList = tmpName.split("_"); 1546 switch (newName) { 1547 case consts.line.ROOT: 1548 case consts.line.ROOTS: 1549 case consts.line.CENTER: 1550 case consts.line.BOTTOM: 1551 case consts.line.NOLINE: 1552 tmpList[0] = view.makeNodeLineClassEx(node) + newName; 1553 break; 1554 case consts.folder.OPEN: 1555 case consts.folder.CLOSE: 1556 case consts.folder.DOCU: 1557 tmpList[1] = newName; 1558 break; 1559 } 1560 obj.attr("class", tmpList.join("_")); 1561 if (newName !== consts.folder.DOCU) { 1562 obj.removeAttr("disabled"); 1563 } else { 1564 obj.attr("disabled", "disabled"); 1565 } 1566 }, 1567 selectNode: function (setting, node, addFlag) { 1568 if (!addFlag) { 1569 view.cancelPreSelectedNode(setting, null, node); 1570 } 1571 $$(node, consts.id.A, setting).addClass(consts.node.CURSELECTED); 1572 data.addSelectedNode(setting, node); 1573 setting.treeObj.trigger(consts.event.SELECTED, [setting.treeId, node]); 1574 }, 1575 setNodeFontCss: function (setting, treeNode) { 1576 var aObj = $$(treeNode, consts.id.A, setting), 1577 fontCss = view.makeNodeFontCss(setting, treeNode); 1578 if (fontCss) { 1579 aObj.css(fontCss); 1580 } 1581 }, 1582 setNodeLineIcos: function (setting, node) { 1583 if (!node) return; 1584 var switchObj = $$(node, consts.id.SWITCH, setting), 1585 ulObj = $$(node, consts.id.UL, setting), 1586 icoObj = $$(node, consts.id.ICON, setting), 1587 ulLine = view.makeUlLineClass(setting, node); 1588 if (ulLine.length == 0) { 1589 ulObj.removeClass(consts.line.LINE); 1590 } else { 1591 ulObj.addClass(ulLine); 1592 } 1593 switchObj.attr("class", view.makeNodeLineClass(setting, node)); 1594 if (node.isParent) { 1595 switchObj.removeAttr("disabled"); 1596 } else { 1597 switchObj.attr("disabled", "disabled"); 1598 } 1599 icoObj.removeAttr("style"); 1600 icoObj.attr("style", view.makeNodeIcoStyle(setting, node)); 1601 icoObj.attr("class", view.makeNodeIcoClass(setting, node)); 1602 }, 1603 setNodeName: function (setting, node) {
1604 var title = data.getNodeTitle(setting, node), 1605 nObj = $$(node, consts.id.SPAN, setting); 1606 nObj.empty(); 1607 if (setting.view.nameIsHTML) { 1608 nObj.html(data.getNodeName(setting, node)); 1609 } else { 1610 nObj.text(data.getNodeName(setting, node)); 1611 } 1612 if (tools.apply(setting.view.showTitle, [setting.treeId, node], setting.view.showTitle)) { 1613 var aObj = $$(node, consts.id.A, setting); 1614 aObj.attr("title", !title ? "" : title); 1615 } 1616 }, 1617 setNodeTarget: function (setting, node) { 1618 var aObj = $$(node, consts.id.A, setting); 1619 aObj.attr("target", view.makeNodeTarget(node)); 1620 }, 1621 setNodeUrl: function (setting, node) { 1622 var aObj = $$(node, consts.id.A, setting), 1623 url = view.makeNodeUrl(setting, node); 1624 if (url == null || url.length == 0) { 1625 aObj.removeAttr("href"); 1626 } else { 1627 aObj.attr("href", url); 1628 } 1629 }, 1630 switchNode: function (setting, node) { 1631 if (node.open || !tools.canAsync(setting, node)) { 1632 view.expandCollapseNode(setting, node, !node.open); 1633 } else if (setting.async.enable) { 1634 if (!view.asyncNode(setting, node)) { 1635 view.expandCollapseNode(setting, node, !node.open); 1636 return; 1637 } 1638 } else if (node) { 1639 view.expandCollapseNode(setting, node, !node.open); 1640 } 1641 } 1642 }; 1643 // zTree defind 1644 $.fn.zTree = { 1645 consts: _consts, 1646 _z: { 1647 tools: tools, 1648 view: view, 1649 event: event, 1650 data: data 1651 }, 1652 getZTreeObj: function (treeId) { 1653 var o = data.getZTreeTools(treeId); 1654 return o ? o : null; 1655 }, 1656 destroy: function (treeId) { 1657 if (!!treeId && treeId.length > 0) { 1658 view.destroy(data.getSetting(treeId)); 1659 } else { 1660 for (var s in settings) { 1661 view.destroy(settings[s]); 1662 } 1663 } 1664 }, 1665 init: function (obj, zSetting, zNodes) { 1666 var setting = tools.clone(_setting); 1667 $.extend(true, setting, zSetting); 1668 setting.treeId = obj.attr("id"); 1669 setting.treeObj = obj; 1670 setting.treeObj.empty(); 1671 settings[setting.treeId] = setting; 1672 //For some older browser,(e.g., ie6) 1673 if (typeof document.body.style.maxHeight === "undefined") { 1674 setting.view.expandSpeed = ""; 1675 } 1676 data.initRoot(setting); 1677 var root = data.getRoot(setting), 1678 childKey = setting.data.key.children; 1679 zNodes = zNodes ? tools.clone(tools.isArray(zNodes) ? zNodes : [zNodes]) : []; 1680 if (setting.data.simpleData.enable) { 1681 root[childKey] = data.transformTozTreeFormat(setting, zNodes); 1682 } else { 1683 root[childKey] = zNodes; 1684 } 1685 1686 data.initCache(setting); 1687 event.unbindTree(setting); 1688 event.bindTree(setting); 1689 event.unbindEvent(setting); 1690 event.bindEvent(setting); 1691 1692 var zTreeTools = { 1693 setting: setting, 1694 addNodes: function (parentNode, index, newNodes, isSilent) { 1695 if (!parentNode) parentNode = null; 1696 if (parentNode && !parentNode.isParent && setting.data.keep.leaf) return null; 1697 1698 var i = parseInt(index, 10); 1699 if (isNaN(i)) { 1700 isSilent = !!newNodes; 1701 newNodes = index; 1702 index = -1; 1703 } else { 1704 index = i; 1705 } 1706 if (!newNodes) return null; 1707 1708 1709 var xNewNodes = tools.clone(tools.isArray(newNodes) ? newNodes : [newNodes]); 1710 1711 function addCallback() { 1712 view.addNodes(setting, parentNode, index, xNewNodes, (isSilent == true)); 1713 } 1714 1715 if (tools.canAsync(setting, parentNode)) { 1716 view.asyncNode(setting, parentNode, isSilent, addCallback); 1717 } else { 1718 addCallback(); 1719 } 1720 return xNewNodes; 1721 }, 1722 cancelSelectedNode: function (node) { 1723 view.cancelPreSelectedNode(setting, node); 1724 }, 1725 destroy: function () { 1726 view.destroy(setting); 1727 }, 1728 expandAll: function (expandFlag) { 1729 expandFlag = !!expandFlag; 1730 view.expandCollapseSonNode(setting, null, expandFlag, true); 1731 return expandFlag; 1732 }, 1733 expandNode: function (node, expandFlag, sonSign, focus, callbackFlag) { 1734 if (!node || !node.isParent) return null; 1735 if (expandFlag !== true && expandFlag !== false) { 1736 expandFlag = !node.open; 1737 } 1738 callbackFlag = !!callbackFlag; 1739 1740 if (callbackFlag && expandFlag && (tools.apply(setting.callback.beforeE
1740xpand, [setting.treeId, node], true) == false)) { 1741 return null; 1742 } else if (callbackFlag && !expandFlag && (tools.apply(setting.callback.beforeCollapse, [setting.treeId, node], true) == false)) { 1743 return null; 1744 } 1745 if (expandFlag && node.parentTId) { 1746 view.expandCollapseParentNode(setting, node.getParentNode(), expandFlag, false); 1747 } 1748 if (expandFlag === node.open && !sonSign) { 1749 return null; 1750 } 1751 1752 data.getRoot(setting).expandTriggerFlag = callbackFlag; 1753 if (!tools.canAsync(setting, node) && sonSign) { 1754 view.expandCollapseSonNode(setting, node, expandFlag, true, showNodeFocus); 1755 } else { 1756 node.open = !expandFlag; 1757 view.switchNode(this.setting, node); 1758 showNodeFocus(); 1759 } 1760 return expandFlag; 1761 1762 function showNodeFocus() { 1763 var a = $$(node, setting).get(0); 1764 if (a && focus !== false) { 1765 view.scrollIntoView(a); 1766 } 1767 } 1768 }, 1769 getNodes: function () { 1770 return data.getNodes(setting); 1771 }, 1772 getNodeByParam: function (key, value, parentNode) { 1773 if (!key) return null; 1774 return data.getNodeByParam(setting, parentNode ? parentNode[setting.data.key.children] : data.getNodes(setting), key, value); 1775 }, 1776 getNodeByTId: function (tId) { 1777 return data.getNodeCache(setting, tId); 1778 }, 1779 getNodesByParam: function (key, value, parentNode) { 1780 if (!key) return null; 1781 return data.getNodesByParam(setting, parentNode ? parentNode[setting.data.key.children] : data.getNodes(setting), key, value); 1782 }, 1783 getNodesByParamFuzzy: function (key, value, parentNode) { 1784 if (!key) return null; 1785 return data.getNodesByParamFuzzy(setting, parentNode ? parentNode[setting.data.key.children] : data.getNodes(setting), key, value); 1786 }, 1787 getNodesByFilter: function (filter, isSingle, parentNode, invokeParam) { 1788 isSingle = !!isSingle; 1789 if (!filter || (typeof filter != "function")) return (isSingle ? null : []); 1790 return data.getNodesByFilter(setting, parentNode ? parentNode[setting.data.key.children] : data.getNodes(setting), filter, isSingle, invokeParam); 1791 }, 1792 getNodeIndex: function (node) { 1793 if (!node) return null; 1794 var childKey = setting.data.key.children, 1795 parentNode = (node.parentTId) ? node.getParentNode() : data.getRoot(setting); 1796 for (var i = 0, l = parentNode[childKey].length; i < l; i++) { 1797 if (parentNode[childKey][i] == node) return i; 1798 } 1799 return -1; 1800 }, 1801 getSelectedNodes: function () { 1802 var r = [], list = data.getRoot(setting).curSelectedList; 1803 for (var i = 0, l = list.length; i < l; i++) { 1804 r.push(list[i]); 1805 } 1806 return r; 1807 }, 1808 isSelectedNode: function (node) { 1809 return data.isSelectedNode(setting, node); 1810 }, 1811 reAsyncChildNodesPromise: function (parentNode, reloadType, isSilent) { 1812 var promise = new Promise(function(resolve, reject) { 1813 try { 1814 zTreeTools.reAsyncChildNodes(parentNode, reloadType, isSilent, function() { 1815 resolve(parentNode); 1816 }); 1817 } catch(e) { 1818 reject(e); 1819 } 1820 }); 1821 return promise; 1822 }, 1823 reAsyncChildNodes: function (parentNode, reloadType, isSilent, callback) { 1824 if (!this.setting.async.enable) return;
1825 var isRoot = !parentNode; 1826 if (isRoot) { 1827 parentNode = data.getRoot(setting); 1828 } 1829 if (reloadType == "refresh") { 1830 var childKey = this.setting.data.key.children; 1831 for (var i = 0, l = parentNode[childKey] ? parentNode[childKey].length : 0; i < l; i++) { 1832 data.removeNodeCache(setting, parentNode[childKey][i]); 1833 } 1834 data.removeSelectedNode(setting); 1835 parentNode[childKey] = []; 1836 if (isRoot) { 1837 this.setting.treeObj.empty(); 1838 } else { 1839 var ulObj = $$(parentNode, consts.id.UL, setting); 1840 ulObj.empty(); 1841 } 1842 } 1843 view.asyncNode(this.setting, isRoot ? null : parentNode, !!isSilent, callback); 1844 }, 1845 refresh: function () { 1846 this.setting.treeObj.empty(); 1847 var root = data.getRoot(setting), 1848 nodes = root[setting.data.key.children] 1849 data.initRoot(setting); 1850 root[setting.data.key.children] = nodes 1851 data.initCache(setting); 1852 view.createNodes(setting, 0, root[setting.data.key.children], null, -1); 1853 }, 1854 removeChildNodes: function (node) { 1855 if (!node) return null; 1856 var childKey = setting.data.key.children, 1857 nodes = node[childKey]; 1858 view.removeChildNodes(setting, node); 1859 return nodes ? nodes : null; 1860 }, 1861 removeNode: function (node, callbackFlag) { 1862 if (!node) return; 1863 callbackFlag = !!callbackFlag; 1864 if (callbackFlag && tools.apply(setting.callback.beforeRemove, [setting.treeId, node], true) == false) return; 1865 view.removeNode(setting, node); 1866 if (callbackFlag) { 1867 this.setting.treeObj.trigger(consts.event.REMOVE, [setting.treeId, node]); 1868 } 1869 }, 1870 selectNode: function (node, addFlag, isSilent) { 1871 if (!node) return; 1872 if (tools.uCanDo(setting)) { 1873 addFlag = setting.view.selectedMulti && addFlag; 1874 if (node.parentTId) { 1875 view.expandCollapseParentNode(setting, node.getParentNode(), true, false, showNodeFocus); 1876 } else if (!isSilent) { 1877 try { 1878 $$(node, setting).focus().blur(); 1879 } catch (e) { 1880 } 1881 } 1882 view.selectNode(setting, node, addFlag); 1883 } 1884 1885 function showNodeFocus() { 1886 if (isSilent) { 1887 return; 1888 } 1889 var a = $$(node, setting).get(0); 1890 view.scrollIntoView(a); 1891 } 1892 }, 1893 transformTozTreeNodes: function (simpleNodes) { 1894 return data.transformTozTreeFormat(setting, simpleNodes); 1895 }, 1896 transformToArray: function (nodes) { 1897 return data.transformToArrayFormat(setting, nodes); 1898 }, 1899 updateNode: function (node, checkTypeFlag) { 1900 if (!node) return; 1901 var nObj = $$(node, setting); 1902 if (nObj.get(0) && tools.uCanDo(setting)) { 1903 view.setNodeName(setting, node); 1904 view.setNodeTarget(setting, node); 1905 view.setNodeUrl(setting, node); 1906 view.setNodeLineIcos(setting, node); 1907 view.setNodeFontCss(setting, node); 1908 } 1909 } 1910 } 1911 root.treeTools = zTreeTools; 1912 data.setZTreeTools(setting, zTreeTools); 1913 1914 if (root[childKey] && root[childKey].length > 0) { 1915 view.createNodes(setting, 0, root[childKey], null, -1); 1916 } else if (setting.async.enable && setting.async.url && setting.async.url !== '') { 1917 view.asyncNode(setting); 1918 } 1919 return zTreeTools; 1920 } 1921 }; 1922 1923 var zt = $.fn.zTree, 1924 $$ = tools.$, 1925 consts = zt.consts; 1926})(jQuery); 1927/* 1928 * JQuery zTree excheck v3.5.29 1929 * http://treejs.cn/ 1930 * 1931 * Copyright (c) 2010 Hunter.z 1932 * 1933 * Licensed same as jquery - MIT License 1934 * http://www.opensource.org/licenses/mit-license.php 1935 * 1936 * email: [email protected] 1937 * Date: 2017-06-19 1938 */ 1939(function($){ 1940 //default consts of excheck 1941 var _consts = { 1942 event: { 1943 CHECK: "ztree_check" 1944 }, 1945 id: { 1946 CHECK: "_check" 1947 }, 1948 checkbox: { 1949 STYLE: "checkbox", 1950 DEFAULT: "chk", 1951 DISABLED: "disable", 1952 FALSE: "false", 1953 TRUE: "true", 1954 FULL: "full", 1955 PART: "part", 1956 FOCUS: "focus" 1957 }, 1958 radio: { 1959 STYLE: "radio", 1960 TYPE_ALL: "all", 1961 TYPE_LEVEL: "level" 1962 } 1963 }, 1964 //default setting of excheck 1965 _setting = { 1966 check: { 1967 enable: false, 1968 autoCheckTrigger: false, 1969 chkStyle: _consts.checkbox.STYLE, 1970 nocheckInherit: false, 1971 chkDisabledInherit: false, 1972 radioType: _consts.radio.TYPE_LEVEL, 1973 chkboxType: { 1974 "Y": "ps", 1975 "N": "ps" 1976 } 1977 }, 1978 data: { 1979 key: { 1980 checked: "checked" 1981 } 1982 }, 1983 callback: { 1984 beforeCheck:null, 1985 onCheck:null 1986 } 1987 }, 1988 //default root of excheck 1989 _initRoot = function (setting) { 1990 var r = data.getRoot(setting); 1991 r.radioCheckedList = []; 1992 }, 1993 //default cache of excheck 1994 _initCache = function(treeId) {}, 1995 //default bind event of excheck 1996 _bindEvent = function(setting) { 1997 var o = setting.treeObj, 1998 c = consts.event; 1999 o.bind(c.CHECK, function (event, srcEvent, treeId, node) { 2000 event.srcEvent = srcEvent; 2001 tools.apply(setting.callback.onCheck, [event, treeId, node]); 2002 }); 2003 }, 2004 _unbindEvent = function(setting) { 2005 var o = setting.treeObj, 2006 c = consts.event; 2007 o.unbind(c.CHECK); 2008 }, 2009 //default event proxy of excheck 2010 _eventProxy = function(e) { 2011 var target = e.target, 2012 setting = data.getSetting(e.data.treeId), 2013 tId = "", node = null, 2014 nodeEventType = "", treeEventType = "", 2015 nodeEventCallback = null, treeEventCallback = null; 2016 2017 if (tools.eqs(e.type, "mouseover")) { 2018 if (setting.check.enable && tools.eqs(target.tagName, "span") && target.getAttribute("treeNode"+ consts.id.CHECK) !== null) { 2019 tId = tools.getNodeMainDom(target).id; 2020 nodeEventType = "mouseoverCheck"; 2021 } 2022 } else if (tools.eqs(e.type, "mouseout")) { 2023 if (setting.check.enable && tools.eqs(target.tagName, "span") && target.getAttribute("treeNode"+ consts.id.CHECK) !== null) { 2024 tId = tools.getNodeMainDom(target).id; 2025 nodeEventType = "mouseoutCheck"; 2026 } 2027 } else if (tools.eqs(e.type, "click")) { 2028 if (setting.check.enable && tools.eqs(target.tagName, "span") && target.getAttribute("treeNode"+ consts.id.CHECK) !== null) { 2029 tId = tools.getNodeMainDom(target).id; 2030 nodeEventType = "checkNode"; 2031 } 2032 } 2033 if (tId.length>0) { 2034 node = data.getNodeCache(setting, tId); 2035 switch (nodeEventType) { 2036 case "checkNode" : 2037 nodeEventCallback = _handler.onCheckNode; 2038 break; 2039 case "mouseoverCheck" : 2040 nodeEventCallback = _handler.onMouseoverCheck; 2041 break; 2042 case "mouseoutCheck" : 2043 nodeEventCallback = _handler.onMouseoutCheck; 2044 break; 2045 } 2046 } 2047 var proxyResult = { 2048 stop: nodeEventType === "checkNode", 2049 node: node, 2050 nodeEventType: nodeEventType, 2051 nodeEventCallback: nodeEventCallback, 2052 treeEventType: treeEventType, 2053 treeEventCallback: treeEventCallback 2054 }; 2055 return proxyResult 2056 }, 2057 //default init node of excheck 2058 _initNode = function(setting, level, n, parentNode, isFirstNode, isLastNode, openFlag) { 2059 if (!n) return; 2060 var checkedKey = setting.data.key.checked; 2061 if (typeof n[checkedKey] == "string") n[checkedKey] = tools.eqs(n[checkedKey], "true"); 2062 n[checkedKey] = !!n[checkedKey]; 2063 n.checkedOld = n[checkedKey]; 2064 if (typeof n.nocheck == "string") n.nocheck = tools.eqs(n.nocheck, "true");
2065 n.nocheck = !!n.nocheck || (setting.check.nocheckInherit && parentNode && !!parentNode.nocheck); 2066 if (typeof n.chkDisabled == "string") n.chkDisabled = tools.eqs(n.chkDisabled, "true"); 2067 n.chkDisabled = !!n.chkDisabled || (setting.check.chkDisabledInherit && parentNode && !!parentNode.chkDisabled); 2068 if (typeof n.halfCheck == "string") n.halfCheck = tools.eqs(n.halfCheck, "true"); 2069 n.halfCheck = !!n.halfCheck; 2070 n.check_Child_State = -1; 2071 n.check_Focus = false; 2072 n.getCheckStatus = function() {return data.getCheckStatus(setting, n);}; 2073 2074 if (setting.check.chkStyle == consts.radio.STYLE && setting.check.radioType == consts.radio.TYPE_ALL && n[checkedKey] ) { 2075 var r = data.getRoot(setting); 2076 r.radioCheckedList.push(n); 2077 } 2078 }, 2079 //add dom for check 2080 _beforeA = function(setting, node, html) { 2081 var checkedKey = setting.data.key.checked; 2082 if (setting.check.enable) { 2083 data.makeChkFlag(setting, node); 2084 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>"); 2085 } 2086 }, 2087 //update zTreeObj, add method of check 2088 _zTreeTools = function(setting, zTreeTools) { 2089 zTreeTools.checkNode = function(node, checked, checkTypeFlag, callbackFlag) { 2090 var checkedKey = this.setting.data.key.checked; 2091 if (node.chkDisabled === true) return; 2092 if (checked !== true && checked !== false) { 2093 checked = !node[checkedKey]; 2094 } 2095 callbackFlag = !!callbackFlag; 2096 2097 if (node[checkedKey] === checked && !checkTypeFlag) { 2098 return; 2099 } else if (callbackFlag && tools.apply(this.setting.callback.beforeCheck, [this.setting.treeId, node], true) == false) { 2100 return; 2101 } 2102 if (tools.uCanDo(this.setting) && this.setting.check.enable && node.nocheck !== true) { 2103 node[checkedKey] = checked; 2104 var checkObj = $$(node, consts.id.CHECK, this.setting); 2105 if (checkTypeFlag || this.setting.check.chkStyle === consts.radio.STYLE) view.checkNodeRelation(this.setting, node); 2106 view.setChkClass(this.setting, checkObj, node); 2107 view.repairParentChkClassWithSelf(this.setting, node); 2108 if (callbackFlag) { 2109 this.setting.treeObj.trigger(consts.event.CHECK, [null, this.setting.treeId, node]); 2110 } 2111 } 2112 } 2113 2114 zTreeTools.checkAllNodes = function(checked) { 2115 view.repairAllChk(this.setting, !!checked); 2116 } 2117 2118 zTreeTools.getCheckedNodes = function(checked) { 2119 var childKey = this.setting.data.key.children; 2120 checked = (checked !== false); 2121 return data.getTreeCheckedNodes(this.setting, data.getRoot(this.setting)[childKey], checked); 2122 } 2123 2124 zTreeTools.getChangeCheckedNodes = function() { 2125 var childKey = this.setting.data.key.children; 2126 return data.getTreeChangeCheckedNodes(this.setting, data.getRoot(this.setting)[childKey]); 2127 } 2128 2129 zTreeTools.setChkDisabled = function(node, disabled, inheritParent, inheritChildren) { 2130 disabled = !!disabled; 2131 inheritParent = !!inheritParent; 2132 inheritChildren = !!inheritChildren; 2133 view.repairSonChkDisabled(this.setting, node, disabled, inheritChildren); 2134 view.repairParentChkDisabled(this.setting, node.getParentNode(), disabled, inheritParent); 2135 } 2136 2137 var _updateNode = zTreeTools.updateNode; 2138 zTreeTools.updateNode = function(node, checkTypeFlag) { 2139 if (_updateNode) _updateNode.apply(zTreeTools, arguments); 2140 if (!node || !this.setting.check.enable) return; 2141 var nObj = $$(node, this.setting); 2142 if (nObj.get(0) && tools.uCanDo(this.setting)) { 2143 var checkObj = $$(node, consts.id.CHECK, this.setting); 2144 if (checkTypeFlag == true || this.setting.check.chkStyle === consts.radio.STYLE) view.checkNodeRelation(this.setting, node); 2145 view.setChkClass(this.setting, checkObj, node); 2146 view.repairParentChkClassWithSelf(this.setting, node); 2147 } 2148 } 2149 }, 2150 //method of operate data 2151 _data = { 2152 getRadioCheckedList: function(setting) { 2153 var checkedList = data.getRoot(setting).radioCheckedList; 2154 for (var i=0, j=checkedList.length; i<j; i++) { 2155 if(!data.getNodeCache(setting, checkedList[i].tId)) { 2156 checkedList.splice(i, 1); 2157 i--; j--; 2158 } 2159 } 2160 return checkedList; 2161 }, 2162 getCheckStatus: function(setting, node) { 2163 if (!setting.check.enable || node.nocheck || node.chkDisabled) return null; 2164 var checkedKey = setting.data.key.checked, 2165 r = { 2166 checked: node[checkedKey], 2167 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))) 2168 }; 2169 return r; 2170 }, 2171 getTreeCheckedNodes: function(setting, nodes, checked, results) {
2172 if (!nodes) return []; 2173 var childKey = setting.data.key.children, 2174 checkedKey = setting.data.key.checked, 2175 onlyOne = (checked && setting.check.chkStyle == consts.radio.STYLE && setting.check.radioType == consts.radio.TYPE_ALL); 2176 results = !results ? [] : results; 2177 for (var i = 0, l = nodes.length; i < l; i++) { 2178 if (nodes[i].nocheck !== true && nodes[i].chkDisabled !== true && nodes[i][checkedKey] == checked) { 2179 results.push(nodes[i]); 2180 if(onlyOne) { 2181 break; 2182 } 2183 } 2184 data.getTreeCheckedNodes(setting, nodes[i][childKey], checked, results); 2185 if(onlyOne && results.length > 0) { 2186 break; 2187 } 2188 } 2189 return results; 2190 }, 2191 getTreeChangeCheckedNodes: function(setting, nodes, results) { 2192 if (!nodes) return []; 2193 var childKey = setting.data.key.children, 2194 checkedKey = setting.data.key.checked; 2195 results = !results ? [] : results; 2196 for (var i = 0, l = nodes.length; i < l; i++) { 2197 if (nodes[i].nocheck !== true && nodes[i].chkDisabled !== true && nodes[i][checkedKey] != nodes[i].checkedOld) { 2198 results.push(nodes[i]); 2199 } 2200 data.getTreeChangeCheckedNodes(setting, nodes[i][childKey], results); 2201 } 2202 return results; 2203 }, 2204 makeChkFlag: function(setting, node) { 2205 if (!node) return; 2206 var childKey = setting.data.key.children, 2207 checkedKey = setting.data.key.checked, 2208 chkFlag = -1; 2209 if (node[childKey]) { 2210 for (var i = 0, l = node[childKey].length; i < l; i++) { 2211 var cNode = node[childKey][i]; 2212 var tmp = -1; 2213 if (setting.check.chkStyle == consts.radio.STYLE) { 2214 if (cNode.nocheck === true || cNode.chkDisabled === true) { 2215 tmp = cNode.check_Child_State; 2216 } else if (cNode.halfCheck === true) { 2217 tmp = 2; 2218 } else if (cNode[checkedKey]) { 2219 tmp = 2; 2220 } else { 2221 tmp = cNode.check_Child_State > 0 ? 2:0; 2222 } 2223 if (tmp == 2) { 2224 chkFlag = 2; break; 2225 } else if (tmp == 0){ 2226 chkFlag = 0; 2227 } 2228 } else if (setting.check.chkStyle == consts.checkbox.STYLE) { 2229 if (cNode.nocheck === true || cNode.chkDisabled === true) { 2230 tmp = cNode.check_Child_State; 2231 } else if (cNode.halfCheck === true) { 2232 tmp = 1; 2233 } else if (cNode[checkedKey] ) { 2234 tmp = (cNode.check_Child_State === -1 || cNode.check_Child_State === 2) ? 2 : 1; 2235 } else { 2236 tmp = (cNode.check_Child_State > 0) ? 1 : 0; 2237 } 2238 if (tmp === 1) { 2239 chkFlag = 1; break; 2240 } else if (tmp === 2 && chkFlag > -1 && i > 0 && tmp !== chkFlag) { 2241 chkFlag = 1; break; 2242 } else if (chkFlag === 2 && tmp > -1 && tmp < 2) { 2243 chkFlag = 1; break; 2244 } else if (tmp > -1) { 2245 chkFlag = tmp; 2246 } 2247 } 2248 } 2249 } 2250 node.check_Child_State = chkFlag; 2251 } 2252 }, 2253 //method of event proxy 2254 _event = { 2255 2256 }, 2257 //method of event handler 2258 _handler = { 2259 onCheckNode: function (event, node) { 2260 if (node.chkDisabled === true) return false; 2261 var setting = data.getSetting(event.data.treeId), 2262 checkedKey = setting.data.key.checked; 2263 if (tools.apply(setting.callback.beforeCheck, [setting.treeId, node], true) == false) return true; 2264 node[checkedKey] = !node[checkedKey]; 2265 view.checkNodeRelation(setting, node); 2266 var checkObj = $$(node, consts.id.CHECK, setting); 2267 view.setChkClass(setting, checkObj, node); 2268 view.repairParentChkClassWithSelf(setting, node); 2269 setting.treeObj.trigger(consts.event.CHECK, [event, setting.treeId, node]); 2270 return true; 2271 }, 2272 onMouseoverCheck: function(event, node) { 2273 if (node.chkDisabled === true) return false; 2274 var setting = data.getSetting(event.data.treeId), 2275 checkObj = $$(node, consts.id.CHECK, setting); 2276 node.check_Focus = true; 2277 view.setChkClass(setting, checkObj, node); 2278 return true; 2279 }, 2280 onMouseoutCheck: function(event, node) { 2281 if (node.chkDisabled === true) return false; 2282 var setting = data.getSetting(event.data.treeId), 2283 checkObj = $$(node, consts.id.CHECK, setting); 2284 node.check_Focus = false; 2285 view.setChkClass(setting, checkObj, node); 2286 return true; 2287 } 2288 }, 2289 //method of tools for zTree 2290 _tools = { 2291 2292 }, 2293 //method of operate ztree dom 2294 _view = { 2295 checkNodeRelation: function(setting, node) { 2296 var pNode, i, l, 2297 childKey = setting.data.key.children, 2298 checkedKey = setting.data.key.checked, 2299 r = consts.radio; 2300 if (setting.check.chkStyle == r.STYLE) { 2301 var checkedList = data.getRadioCheckedList(setting); 2302 if (node[checkedKey]) { 2303 if (setting.check.radioType == r.TYPE_ALL) { 2304 for (i = checkedList.length-1; i >= 0; i--) { 2305 pNode = checkedList[i]; 2306 if (pNode[checkedKey] && pNode != node) { 2307 pNode[checkedKey] = false;
2308 checkedList.splice(i, 1); 2309 2310 view.setChkClass(setting, $$(pNode, consts.id.CHECK, setting), pNode); 2311 if (pNode.parentTId != node.parentTId) { 2312 view.repairParentChkClassWithSelf(setting, pNode); 2313 } 2314 } 2315 } 2316 checkedList.push(node); 2317 } else { 2318 var parentNode = (node.parentTId) ? node.getParentNode() : data.getRoot(setting); 2319 for (i = 0, l = parentNode[childKey].length; i < l; i++) { 2320 pNode = parentNode[childKey][i]; 2321 if (pNode[checkedKey] && pNode != node) { 2322 pNode[checkedKey] = false; 2323 view.setChkClass(setting, $$(pNode, consts.id.CHECK, setting), pNode); 2324 } 2325 } 2326 } 2327 } else if (setting.check.radioType == r.TYPE_ALL) { 2328 for (i = 0, l = checkedList.length; i < l; i++) { 2329 if (node == checkedList[i]) { 2330 checkedList.splice(i, 1); 2331 break; 2332 } 2333 } 2334 } 2335 2336 } else { 2337 if (node[checkedKey] && (!node[childKey] || node[childKey].length==0 || setting.check.chkboxType.Y.indexOf("s") > -1)) { 2338 view.setSonNodeCheckBox(setting, node, true); 2339 } 2340 if (!node[checkedKey] && (!node[childKey] || node[childKey].length==0 || setting.check.chkboxType.N.indexOf("s") > -1)) { 2341 view.setSonNodeCheckBox(setting, node, false); 2342 } 2343 if (node[checkedKey] && setting.check.chkboxType.Y.indexOf("p") > -1) { 2344 view.setParentNodeCheckBox(setting, node, true); 2345 } 2346 if (!node[checkedKey] && setting.check.chkboxType.N.indexOf("p") > -1) { 2347 view.setParentNodeCheckBox(setting, node, false); 2348 } 2349 } 2350 }, 2351 makeChkClass: function(setting, node) { 2352 var checkedKey = setting.data.key.checked, 2353 c = consts.checkbox, r = consts.radio, 2354 fullStyle = ""; 2355 if (node.chkDisabled === true) { 2356 fullStyle = c.DISABLED; 2357 } else if (node.halfCheck) { 2358 fullStyle = c.PART; 2359 } else if (setting.check.chkStyle == r.STYLE) { 2360 fullStyle = (node.check_Child_State < 1)? c.FULL:c.PART; 2361 } else { 2362 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); 2363 } 2364 var chkName = setting.check.chkStyle + "_" + (node[checkedKey] ? c.TRUE : c.FALSE) + "_" + fullStyle; 2365 chkName = (node.check_Focus && node.chkDisabled !== true) ? chkName + "_" + c.FOCUS : chkName; 2366 return consts.className.BUTTON + " " + c.DEFAULT + " " + chkName; 2367 }, 2368 repairAllChk: function(setting, checked) { 2369 if (setting.check.enable && setting.check.chkStyle === consts.checkbox.STYLE) { 2370 var checkedKey = setting.data.key.checked, 2371 childKey = setting.data.key.children, 2372 root = data.getRoot(setting); 2373 for (var i = 0, l = root[childKey].length; i<l ; i++) { 2374 var node = root[childKey][i]; 2375 if (node.nocheck !== true && node.chkDisabled !== true) { 2376 node[checkedKey] = checked; 2377 } 2378 view.setSonNodeCheckBox(setting, node, checked); 2379 } 2380 } 2381 }, 2382 repairChkClass: function(setting, node) { 2383 if (!node) return; 2384 data.makeChkFlag(setting, node); 2385 if (node.nocheck !== true) { 2386 var checkObj = $$(node, consts.id.CHECK, setting); 2387 view.setChkClass(setting, checkObj, node); 2388 } 2389 }, 2390 repairParentChkClass: function(setting, node) { 2391 if (!node || !node.parentTId) return; 2392 var pNode = node.getParentNode(); 2393 view.repairChkClass(setting, pNode); 2394 view.repairParentChkClass(setting, pNode); 2395 }, 2396 repairParentChkClassWithSelf: function(setting, node) { 2397 if (!node) return; 2398 var childKey = setting.data.key.children; 2399 if (node[childKey] && node[childKey].length > 0) { 2400 view.repairParentChkClass(setting, node[childKey][0]); 2401 } else { 2402 view.repairParentChkClass(setting, node); 2403 } 2404 }, 2405 repairSonChkDisabled: function(setting, node, chkDisabled, inherit) { 2406 if (!node) return; 2407 var childKey = setting.data.key.children; 2408 if (node.chkDisabled != chkDisabled) { 2409 node.chkDisabled = chkDisabled; 2410 } 2411 view.repairChkClass(setting, node); 2412 if (node[childKey] && inherit) { 2413 for (var i = 0, l = node[childKey].length; i < l; i++) { 2414 var sNode = node[childKey][i]; 2415 view.repairSonChkDisabled(setting, sNode, chkDisabled, inherit); 2416 } 2417 } 2418 }, 2419 repairParentChkDisabled: function(setting, node, chkDisabled, inherit) { 2420 if (!node) return; 2421 if (node.chkDisabled != chkDisabled && inherit) { 2422 node.chkDisabled = chkDisabled; 2423 } 2424 view.repairChkClass(setting, node); 2425 view.repairParentChkDisabled(setting, node.getParentNode(), chkDisabled, inherit); 2426 }, 2427 setChkClass: function(setting, obj, node) { 2428 if (!obj) return; 2429 if (node.nocheck === true) { 2430 obj.hide(); 2431 } else { 2432 obj.show(); 2433 } 2434 obj.attr('class', view.makeChkClass(setting, node)); 2435 }, 2436 setParentNodeCheckBox: function(setting, node, value, srcNode) { 2437 var childKey = setting.data.key.children, 2438 checkedKey = setting.data.key.checked, 2439 checkObj = $$(node, consts.id.CHECK, setting); 2440 if (!srcNode) srcNode = node;
2441 data.makeChkFlag(setting, node); 2442 if (node.nocheck !== true && node.chkDisabled !== true) { 2443 node[checkedKey] = value; 2444 view.setChkClass(setting, checkObj, node); 2445 if (setting.check.autoCheckTrigger && node != srcNode) { 2446 setting.treeObj.trigger(consts.event.CHECK, [null, setting.treeId, node]); 2447 } 2448 } 2449 if (node.parentTId) { 2450 var pSign = true; 2451 if (!value) { 2452 var pNodes = node.getParentNode()[childKey]; 2453 for (var i = 0, l = pNodes.length; i < l; i++) { 2454 if ((pNodes[i].nocheck !== true && pNodes[i].chkDisabled !== true && pNodes[i][checkedKey]) 2455 || ((pNodes[i].nocheck === true || pNodes[i].chkDisabled === true) && pNodes[i].check_Child_State > 0)) { 2456 pSign = false; 2457 break; 2458 } 2459 } 2460 } 2461 if (pSign) { 2462 view.setParentNodeCheckBox(setting, node.getParentNode(), value, srcNode); 2463 } 2464 } 2465 }, 2466 setSonNodeCheckBox: function(setting, node, value, srcNode) { 2467 if (!node) return; 2468 var childKey = setting.data.key.children, 2469 checkedKey = setting.data.key.checked, 2470 checkObj = $$(node, consts.id.CHECK, setting); 2471 if (!srcNode) srcNode = node; 2472 2473 var hasDisable = false; 2474 if (node[childKey]) { 2475 for (var i = 0, l = node[childKey].length; i < l; i++) { 2476 var sNode = node[childKey][i]; 2477 view.setSonNodeCheckBox(setting, sNode, value, srcNode); 2478 if (sNode.chkDisabled === true) hasDisable = true; 2479 } 2480 } 2481 2482 if (node != data.getRoot(setting) && node.chkDisabled !== true) { 2483 if (hasDisable && node.nocheck !== true) { 2484 data.makeChkFlag(setting, node); 2485 } 2486 if (node.nocheck !== true && node.chkDisabled !== true) { 2487 node[checkedKey] = value; 2488 if (!hasDisable) node.check_Child_State = (node[childKey] && node[childKey].length > 0) ? (value ? 2 : 0) : -1; 2489 } else { 2490 node.check_Child_State = -1; 2491 } 2492 view.setChkClass(setting, checkObj, node); 2493 if (setting.check.autoCheckTrigger && node != srcNode && node.nocheck !== true && node.chkDisabled !== true) { 2494 setting.treeObj.trigger(consts.event.CHECK, [null, setting.treeId, node]); 2495 } 2496 } 2497 2498 } 2499 }, 2500 2501 _z = { 2502 tools: _tools, 2503 view: _view, 2504 event: _event, 2505 data: _data 2506 }; 2507 $.extend(true, $.fn.zTree.consts, _consts); 2508 $.extend(true, $.fn.zTree._z, _z); 2509 2510 var zt = $.fn.zTree, 2511 tools = zt._z.tools, 2512 consts = zt.consts, 2513 view = zt._z.view, 2514 data = zt._z.data, 2515 event = zt._z.event, 2516 $$ = tools.$; 2517 2518 data.exSetting(_setting); 2519 data.addInitBind(_bindEvent); 2520 data.addInitUnBind(_unbindEvent); 2521 data.addInitCache(_initCache); 2522 data.addInitNode(_initNode); 2523 data.addInitProxy(_eventProxy, true); 2524 data.addInitRoot(_initRoot); 2525 data.addBeforeA(_beforeA); 2526 data.addZTreeTools(_zTreeTools); 2527 2528 var _createNodes = view.createNodes; 2529 view.createNodes = function(setting, level, nodes, parentNode, index) { 2530 if (_createNodes) _createNodes.apply(view, arguments); 2531 if (!nodes) return; 2532 view.repairParentChkClassWithSelf(setting, parentNode); 2533 } 2534 var _removeNode = view.removeNode; 2535 view.removeNode = function(setting, node) { 2536 var parentNode = node.getParentNode(); 2537 if (_removeNode) _removeNode.apply(view, arguments); 2538 if (!node || !parentNode) return; 2539 view.repairChkClass(setting, parentNode); 2540 view.repairParentChkClass(setting, parentNode); 2541 } 2542 2543 var _appendNodes = view.appendNodes; 2544 view.appendNodes = function(setting, level, nodes, parentNode, index, initFlag, openFlag) { 2545 var html = ""; 2546 if (_appendNodes) { 2547 html = _appendNodes.apply(view, arguments); 2548 } 2549 if (parentNode) { 2550 data.makeChkFlag(setting, parentNode); 2551 } 2552 return html; 2553 } 2554})(jQuery); 2555/* 2556 * JQuery zTree exedit v3.5.29 2557 * http://treejs.cn/ 2558 * 2559 * Copyright (c) 2010 Hunter.z 2560 * 2561 * Licensed same as jquery - MIT License 2562 * http://www.opensource.org/licenses/mit-license.php 2563 * 2564 * email: [email protected] 2565 * Date: 2017-06-19 2566 */ 2567(function($){ 2568 //default consts of exedit 2569 var _consts = { 2570 event: { 2571 DRAG: "ztree_drag", 2572 DROP: "ztree_drop", 2573 RENAME: "ztree_rename", 2574 DRAGMOVE:"ztree_dragmove" 2575 }, 2576 id: { 2577 EDIT: "_edit", 2578 INPUT: "_input", 2579 REMOVE: "_remove" 2580 }, 2581 move: { 2582 TYPE_INNER: "inner", 2583 TYPE_PREV: "prev",
2584 TYPE_NEXT: "next" 2585 }, 2586 node: { 2587 CURSELECTED_EDIT: "curSelectedNode_Edit", 2588 TMPTARGET_TREE: "tmpTargetzTree", 2589 TMPTARGET_NODE: "tmpTargetNode" 2590 } 2591 }, 2592 //default setting of exedit 2593 _setting = { 2594 edit: { 2595 enable: false, 2596 editNameSelectAll: false, 2597 showRemoveBtn: true, 2598 showRenameBtn: true, 2599 removeTitle: "remove", 2600 renameTitle: "rename", 2601 drag: { 2602 autoExpandTrigger: false, 2603 isCopy: true, 2604 isMove: true, 2605 prev: true, 2606 next: true, 2607 inner: true, 2608 minMoveSize: 5, 2609 borderMax: 10, 2610 borderMin: -5, 2611 maxShowNodeNum: 5, 2612 autoOpenTime: 500 2613 } 2614 }, 2615 view: { 2616 addHoverDom: null, 2617 removeHoverDom: null 2618 }, 2619 callback: { 2620 beforeDrag:null, 2621 beforeDragOpen:null, 2622 beforeDrop:null, 2623 beforeEditName:null, 2624 beforeRename:null, 2625 onDrag:null, 2626 onDragMove:null, 2627 onDrop:null, 2628 onRename:null 2629 } 2630 }, 2631 //default root of exedit 2632 _initRoot = function (setting) { 2633 var r = data.getRoot(setting), rs = data.getRoots(); 2634 r.curEditNode = null; 2635 r.curEditInput = null; 2636 r.curHoverNode = null; 2637 r.dragFlag = 0; 2638 r.dragNodeShowBefore = []; 2639 r.dragMaskList = new Array(); 2640 rs.showHoverDom = true; 2641 }, 2642 //default cache of exedit 2643 _initCache = function(treeId) {}, 2644 //default bind event of exedit 2645 _bindEvent = function(setting) { 2646 var o = setting.treeObj; 2647 var c = consts.event; 2648 o.bind(c.RENAME, function (event, treeId, treeNode, isCancel) { 2649 tools.apply(setting.callback.onRename, [event, treeId, treeNode, isCancel]); 2650 }); 2651 2652 o.bind(c.DRAG, function (event, srcEvent, treeId, treeNodes) { 2653 tools.apply(setting.callback.onDrag, [srcEvent, treeId, treeNodes]); 2654 }); 2655 2656 o.bind(c.DRAGMOVE,function(event, srcEvent, treeId, treeNodes){ 2657 tools.apply(setting.callback.onDragMove,[srcEvent, treeId, treeNodes]); 2658 }); 2659 2660 o.bind(c.DROP, function (event, srcEvent, treeId, treeNodes, targetNode, moveType, isCopy) { 2661 tools.apply(setting.callback.onDrop, [srcEvent, treeId, treeNodes, targetNode, moveType, isCopy]); 2662 }); 2663 }, 2664 _unbindEvent = function(setting) { 2665 var o = setting.treeObj; 2666 var c = consts.event; 2667 o.unbind(c.RENAME); 2668 o.unbind(c.DRAG); 2669 o.unbind(c.DRAGMOVE); 2670 o.unbind(c.DROP); 2671 }, 2672 //default event proxy of exedit 2673 _eventProxy = function(e) { 2674 var target = e.target, 2675 setting = data.getSetting(e.data.treeId), 2676 relatedTarget = e.relatedTarget, 2677 tId = "", node = null, 2678 nodeEventType = "", treeEventType = "", 2679 nodeEventCallback = null, treeEventCallback = null, 2680 tmp = null; 2681 2682 if (tools.eqs(e.type, "mouseover")) { 2683 tmp = tools.getMDom(setting, target, [{tagName:"a", attrName:"treeNode"+consts.id.A}]); 2684 if (tmp) { 2685 tId = tools.getNodeMainDom(tmp).id; 2686 nodeEventType = "hoverOverNode"; 2687 } 2688 } else if (tools.eqs(e.type, "mouseout")) { 2689 tmp = tools.getMDom(setting, relatedTarget, [{tagName:"a", attrName:"treeNode"+consts.id.A}]); 2690 if (!tmp) { 2691 tId = "remove"; 2692 nodeEventType = "hoverOutNode"; 2693 } 2694 } else if (tools.eqs(e.type, "mousedown")) { 2695 tmp = tools.getMDom(setting, target, [{tagName:"a", attrName:"treeNode"+consts.id.A}]); 2696 if (tmp) { 2697 tId = tools.getNodeMainDom(tmp).id; 2698 nodeEventType = "mousedownNode"; 2699 } 2700 } 2701 if (tId.length>0) { 2702 node = data.getNodeCache(setting, tId); 2703 switch (nodeEventType) { 2704 case "mousedownNode" : 2705 nodeEventCallback = _handler.onMousedownNode; 2706 break; 2707 case "hoverOverNode" : 2708 nodeEventCallback = _handler.onHoverOverNode; 2709 break; 2710 case "hoverOutNode" : 2711 nodeEventCallback = _handler.onHoverOutNode; 2712 break; 2713 } 2714 } 2715 var proxyResult = { 2716 stop: false, 2717 node: node, 2718 nodeEventType: nodeEventType, 2719 nodeEventCallback: nodeEventCallback, 2720 treeEventType: treeEventType, 2721 treeEventCallback: treeEventCallback 2722 }; 2723 return proxyResult 2724 }, 2725 //default init node of exedit 2726 _initNode = function(setting, level, n, parentNode, isFirstNode, isLastNode, openFlag) { 2727 if (!n) return; 2728 n.isHover = false; 2729 n.editNameFlag = false; 2730 }, 2731 //update zTreeObj, add method of edit 2732 _zTreeTools = function(setting, zTreeTools) { 2733 zTreeTools.cancelEditName = function(newName) { 2734 var root = data.getRoot(this.setting); 2735 if (!root.curEditNode) return; 2736 view.cancelCurEditNode(this.setting, newName?newName:null, true); 2737 } 2738 zTreeTools.copyNode = function(targetNode, node, moveType, isSilent) { 2739 if (!node) return null; 2740 if (targetNode && !targetNode.isParent && this.setting.data.keep.leaf && moveType === consts.move.TYPE_INNER) return null; 2741 var _this = this, 2742 newNode = tools.clone(node); 2743 if (!targetNode) { 2744 targetNode = null; 2745 moveType = consts.move.TYPE_INNER; 2746 } 2747 if (moveType == consts.move.TYPE_INNER) { 2748 function copyCallback() { 2749 view.addNodes(_this.setting, targetNode, -1, [newNode], isSilent); 2750 } 2751 2752 if (tools.canAsync(this.setting, targetNode)) { 2753 view.asyncNode(this.setting, targetNode, isSilent, copyCallback); 2754 } else { 2755 copyCallback(); 2756 } 2757 } else { 2758 view.addNodes(this.setting, targetNode.parentNode, -1, [newNode], isSilent); 2759 view.moveNode(this.setting, targetNode, newNode, moveType, false, isSilent); 2760 } 2761 return newNode; 2762 } 2763 zTreeTools.editName = function(node) { 2764 if (!node || !node.tId || node !== data.getNodeCache(this.setting, node.tId)) return; 2765 if (node.parentTId) view.expandCollapseParentNode(this.setting, node.getParentNode(), true); 2766 view.editNode(this.setting, node) 2767 } 2768 zTreeTools.moveNode = function(targetNode, node, moveType, isSilent) { 2769 if (!node) return node; 2770 if (targetNode && !targetNode.isParent && this.setting.data.keep.leaf && moveType === consts.move.TYPE_INNER) { 2771 return null; 2772 } else if (targetNode && ((node.parentTId == targetNode.tId && moveType == consts.move.TYPE_INNER) || $$(node, this.setting).find("#" + targetNode.tId).length > 0)) { 2773 return null; 2774 } else if (!targetNode) { 2775 targetNode = null; 2776 } 2777 var _this = this; 2778 function moveCallback() { 2779 view.moveNode(_this.setting, targetNode, node, moveType, false, isSilent); 2780 } 2781 if (tools.canAsync(this.setting, targetNode) && moveType === consts.move.TYPE_INNER) { 2782 view.asyncNode(this.setting, targetNode, isSilent, moveCallback); 2783 } else { 2784 moveCallback(); 2785 } 2786 return node; 2787 } 2788 zTreeTools.setEditable = function(editable) { 2789 this.setting.edit.enable = editable; 2790 return this.refresh(); 2791 } 2792 }, 2793 //method of operate data 2794 _data = { 2795 setSonNodeLevel: function(setting, parentNode, node) { 2796 if (!node) return; 2797 var childKey = setting.data.key.children; 2798 node.level = (parentNode)? parentNode.level + 1 : 0; 2799 if (!node[childKey]) return; 2800 for (var i = 0, l = node[childKey].length; i < l; i++) {
2801 if (node[childKey][i]) data.setSonNodeLevel(setting, node, node[childKey][i]); 2802 } 2803 } 2804 }, 2805 //method of event proxy 2806 _event = { 2807 2808 }, 2809 //method of event handler 2810 _handler = { 2811 onHoverOverNode: function(event, node) { 2812 var setting = data.getSetting(event.data.treeId), 2813 root = data.getRoot(setting); 2814 if (root.curHoverNode != node) { 2815 _handler.onHoverOutNode(event); 2816 } 2817 root.curHoverNode = node; 2818 view.addHoverDom(setting, node); 2819 }, 2820 onHoverOutNode: function(event, node) { 2821 var setting = data.getSetting(event.data.treeId), 2822 root = data.getRoot(setting); 2823 if (root.curHoverNode && !data.isSelectedNode(setting, root.curHoverNode)) { 2824 view.removeTreeDom(setting, root.curHoverNode); 2825 root.curHoverNode = null; 2826 } 2827 }, 2828 onMousedownNode: function(eventMouseDown, _node) { 2829 var i,l, 2830 setting = data.getSetting(eventMouseDown.data.treeId), 2831 root = data.getRoot(setting), roots = data.getRoots(); 2832 //right click can't drag & drop 2833 if (eventMouseDown.button == 2 || !setting.edit.enable || (!setting.edit.drag.isCopy && !setting.edit.drag.isMove)) return true; 2834 2835 //input of edit node name can't drag & drop 2836 var target = eventMouseDown.target, 2837 _nodes = data.getRoot(setting).curSelectedList, 2838 nodes = []; 2839 if (!data.isSelectedNode(setting, _node)) { 2840 nodes = [_node]; 2841 } else { 2842 for (i=0, l=_nodes.length; i<l; i++) { 2843 if (_nodes[i].editNameFlag && tools.eqs(target.tagName, "input") && target.getAttribute("treeNode"+consts.id.INPUT) !== null) { 2844 return true; 2845 } 2846 nodes.push(_nodes[i]); 2847 if (nodes[0].parentTId !== _nodes[i].parentTId) { 2848 nodes = [_node]; 2849 break; 2850 } 2851 } 2852 } 2853 2854 view.editNodeBlur = true; 2855 view.cancelCurEditNode(setting); 2856 2857 var doc = $(setting.treeObj.get(0).ownerDocument), 2858 body = $(setting.treeObj.get(0).ownerDocument.body), curNode, tmpArrow, tmpTarget, 2859 isOtherTree = false, 2860 targetSetting = setting, 2861 sourceSetting = setting, 2862 preNode, nextNode, 2863 preTmpTargetNodeId = null, 2864 preTmpMoveType = null, 2865 tmpTargetNodeId = null, 2866 moveType = consts.move.TYPE_INNER, 2867 mouseDownX = eventMouseDown.clientX, 2868 mouseDownY = eventMouseDown.clientY, 2869 startTime = (new Date()).getTime(); 2870 2871 if (tools.uCanDo(setting)) { 2872 doc.bind("mousemove", _docMouseMove); 2873 } 2874 function _docMouseMove(event) { 2875 //avoid start drag after click node 2876 if (root.dragFlag == 0 && Math.abs(mouseDownX - event.clientX) < setting.edit.drag.minMoveSize 2877 && Math.abs(mouseDownY - event.clientY) < setting.edit.drag.minMoveSize) { 2878 return true; 2879 } 2880 var i, l, tmpNode, tmpDom, tmpNodes, 2881 childKey = setting.data.key.children; 2882 body.css("cursor", "pointer"); 2883 2884 if (root.dragFlag == 0) { 2885 if (tools.apply(setting.callback.beforeDrag, [setting.treeId, nodes], true) == false) { 2886 _docMouseUp(event); 2887 return true; 2888 } 2889 2890 for (i=0, l=nodes.length; i<l; i++) { 2891 if (i==0) { 2892 root.dragNodeShowBefore = []; 2893 } 2894 tmpNode = nodes[i]; 2895 if (tmpNode.isParent && tmpNode.open) { 2896 view.expandCollapseNode(setting, tmpNode, !tmpNode.open); 2897 root.dragNodeShowBefore[tmpNode.tId] = true; 2898 } else { 2899 root.dragNodeShowBefore[tmpNode.tId] = false; 2900 } 2901 } 2902 2903 root.dragFlag = 1; 2904 roots.showHoverDom = false; 2905 tools.showIfameMask(setting, true); 2906 2907 //sort 2908 var isOrder = true, lastIndex = -1; 2909 if (nodes.length>1) { 2910 var pNodes = nodes[0].parentTId ? nodes[0].getParentNode()[childKey] : data.getNodes(setting); 2911 tmpNodes = []; 2912 for (i=0, l=pNodes.length; i<l; i++) { 2913 if (root.dragNodeShowBefore[pNodes[i].tId] !== undefined) { 2914 if (isOrder && lastIndex > -1 && (lastIndex+1) !== i) { 2915 isOrder = false; 2916 } 2917 tmpNodes.push(pNodes[i]); 2918 lastIndex = i; 2919 } 2920 if (nodes.length === tmpNodes.length) { 2921 nodes = tmpNodes; 2922 break; 2923 } 2924 } 2925 } 2926 if (isOrder) { 2927 preNode = nodes[0].getPreNode(); 2928 nextNode = nodes[nodes.length-1].getNextNode(); 2929 } 2930 2931 //set node in selected 2932 curNode = $$("<ul class='zTreeDragUL'></ul>", setting); 2933 for (i=0, l=nodes.length; i<l; i++) { 2934 tmpNode = nodes[i]; 2935 tmpNode.editNameFlag = false;
2936 view.selectNode(setting, tmpNode, i>0); 2937 view.removeTreeDom(setting, tmpNode); 2938 2939 if (i > setting.edit.drag.maxShowNodeNum-1) { 2940 continue; 2941 } 2942 2943 tmpDom = $$("<li id='"+ tmpNode.tId +"_tmp'></li>", setting); 2944 tmpDom.append($$(tmpNode, consts.id.A, setting).clone()); 2945 tmpDom.css("padding", "0"); 2946 tmpDom.children("#" + tmpNode.tId + consts.id.A).removeClass(consts.node.CURSELECTED); 2947 curNode.append(tmpDom); 2948 if (i == setting.edit.drag.maxShowNodeNum-1) { 2949 tmpDom = $$("<li id='"+ tmpNode.tId +"_moretmp'><a> ... </a></li>", setting); 2950 curNode.append(tmpDom); 2951 } 2952 } 2953 curNode.attr("id", nodes[0].tId + consts.id.UL + "_tmp"); 2954 curNode.addClass(setting.treeObj.attr("class")); 2955 curNode.appendTo(body); 2956 2957 tmpArrow = $$("<span class='tmpzTreeMove_arrow'></span>", setting); 2958 tmpArrow.attr("id", "zTreeMove_arrow_tmp"); 2959 tmpArrow.appendTo(body); 2960 2961 setting.treeObj.trigger(consts.event.DRAG, [event, setting.treeId, nodes]); 2962 } 2963 2964 if (root.dragFlag == 1) { 2965 if (tmpTarget && tmpArrow.attr("id") == event.target.id && tmpTargetNodeId && (event.clientX + doc.scrollLeft()+2) > ($("#" + tmpTargetNodeId + consts.id.A, tmpTarget).offset().left)) { 2966 var xT = $("#" + tmpTargetNodeId + consts.id.A, tmpTarget); 2967 event.target = (xT.length > 0) ? xT.get(0) : event.target; 2968 } else if (tmpTarget) { 2969 tmpTarget.removeClass(consts.node.TMPTARGET_TREE); 2970 if (tmpTargetNodeId) $("#" + tmpTargetNodeId + consts.id.A, tmpTarget).removeClass(consts.node.TMPTARGET_NODE + "_" + consts.move.TYPE_PREV) 2971 .removeClass(consts.node.TMPTARGET_NODE + "_" + _consts.move.TYPE_NEXT).removeClass(consts.node.TMPTARGET_NODE + "_" + _consts.move.TYPE_INNER); 2972 } 2973 tmpTarget = null; 2974 tmpTargetNodeId = null; 2975 2976 //judge drag & drop in multi ztree 2977 isOtherTree = false; 2978 targetSetting = setting; 2979 var settings = data.getSettings(); 2980 for (var s in settings) { 2981 if (settings[s].treeId && settings[s].edit.enable && settings[s].treeId != setting.treeId 2982 && (event.target.id == settings[s].treeId || $(event.target).parents("#" + settings[s].treeId).length>0)) { 2983 isOtherTree = true; 2984 targetSetting = settings[s]; 2985 } 2986 } 2987 2988 var docScrollTop = doc.scrollTop(), 2989 docScrollLeft = doc.scrollLeft(), 2990 treeOffset = targetSetting.treeObj.offset(), 2991 scrollHeight = targetSetting.treeObj.get(0).scrollHeight, 2992 scrollWidth = targetSetting.treeObj.get(0).scrollWidth, 2993 dTop = (event.clientY + docScrollTop - treeOffset.top), 2994 dBottom = (targetSetting.treeObj.height() + treeOffset.top - event.clientY - docScrollTop), 2995 dLeft = (event.clientX + docScrollLeft - treeOffset.left), 2996 dRight = (targetSetting.treeObj.width() + treeOffset.left - event.clientX - docScrollLeft), 2997 isTop = (dTop < setting.edit.drag.borderMax && dTop > setting.edit.drag.borderMin), 2998 isBottom = (dBottom < setting.edit.drag.borderMax && dBottom > setting.edit.drag.borderMin), 2999 isLeft = (dLeft < setting.edit.drag.borderMax && dLeft > setting.edit.drag.borderMin), 3000 isRight = (dRight < setting.edit.drag.borderMax && dRight > setting.edit.drag.borderMin), 3001 isTreeInner = dTop > setting.edit.drag.borderMin && dBottom > setting.edit.drag.borderMin && dLeft > setting.edit.drag.borderMin && dRight > setting.edit.drag.borderMin, 3002 isTreeTop = (isTop && targetSetting.treeObj.scrollTop() <= 0), 3003 isTreeBottom = (isBottom && (targetSetting.treeObj.scrollTop() + targetSetting.treeObj.height()+10) >= scrollHeight), 3004 isTreeLeft = (isLeft && targetSetting.treeObj.scrollLeft() <= 0), 3005 isTreeRight = (isRight && (targetSetting.treeObj.scrollLeft() + targetSetting.treeObj.width()+10) >= scrollWidth); 3006 3007 if (event.target && tools.isChildOrSelf(event.target, targetSetting.treeId)) { 3008 //get node <li> dom 3009 var targetObj = event.target; 3010 while (targetObj && targetObj.tagName && !tools.eqs(targetObj.tagName, "li") && targetObj.id != targetSetting.treeId) { 3011 targetObj = targetObj.parentNode; 3012 } 3013 3014 var canMove = true; 3015 //don't move to self or children of self 3016 for (i=0, l=nodes.length; i<l; i++) { 3017 tmpNode = nodes[i]; 3018 if (targetObj.id === tmpNode.tId) { 3019 canMove = false;
3020 break; 3021 } else if ($$(tmpNode, setting).find("#" + targetObj.id).length > 0) { 3022 canMove = false; 3023 break; 3024 } 3025 } 3026 if (canMove && event.target && tools.isChildOrSelf(event.target, targetObj.id + consts.id.A)) { 3027 tmpTarget = $(targetObj); 3028 tmpTargetNodeId = targetObj.id; 3029 } 3030 } 3031 3032 //the mouse must be in zTree 3033 tmpNode = nodes[0]; 3034 if (isTreeInner && tools.isChildOrSelf(event.target, targetSetting.treeId)) { 3035 //judge mouse move in root of ztree 3036 if (!tmpTarget && (event.target.id == targetSetting.treeId || isTreeTop || isTreeBottom || isTreeLeft || isTreeRight) && (isOtherTree || (!isOtherTree && tmpNode.parentTId))) { 3037 tmpTarget = targetSetting.treeObj; 3038 } 3039 //auto scroll top 3040 if (isTop) { 3041 targetSetting.treeObj.scrollTop(targetSetting.treeObj.scrollTop()-10); 3042 } else if (isBottom) { 3043 targetSetting.treeObj.scrollTop(targetSetting.treeObj.scrollTop()+10); 3044 } 3045 if (isLeft) { 3046 targetSetting.treeObj.scrollLeft(targetSetting.treeObj.scrollLeft()-10); 3047 } else if (isRight) { 3048 targetSetting.treeObj.scrollLeft(targetSetting.treeObj.scrollLeft()+10); 3049 } 3050 //auto scroll left 3051 if (tmpTarget && tmpTarget != targetSetting.treeObj && tmpTarget.offset().left < targetSetting.treeObj.offset().left) { 3052 targetSetting.treeObj.scrollLeft(targetSetting.treeObj.scrollLeft()+ tmpTarget.offset().left - targetSetting.treeObj.offset().left); 3053 } 3054 } 3055 3056 curNode.css({ 3057 "top": (event.clientY + docScrollTop + 3) + "px", 3058 "left": (event.clientX + docScrollLeft + 3) + "px" 3059 }); 3060 3061 var dX = 0; 3062 var dY = 0; 3063 if (tmpTarget && tmpTarget.attr("id")!=targetSetting.treeId) { 3064 var tmpTargetNode = tmpTargetNodeId == null ? null: data.getNodeCache(targetSetting, tmpTargetNodeId), 3065 isCopy = ((event.ctrlKey || event.metaKey) && setting.edit.drag.isMove && setting.edit.drag.isCopy) || (!setting.edit.drag.isMove && setting.edit.drag.isCopy), 3066 isPrev = !!(preNode && tmpTargetNodeId === preNode.tId), 3067 isNext = !!(nextNode && tmpTargetNodeId === nextNode.tId), 3068 isInner = (tmpNode.parentTId && tmpNode.parentTId == tmpTargetNodeId), 3069 canPrev = (isCopy || !isNext) && tools.apply(targetSetting.edit.drag.prev, [targetSetting.treeId, nodes, tmpTargetNode], !!targetSetting.edit.drag.prev), 3070 canNext = (isCopy || !isPrev) && tools.apply(targetSetting.edit.drag.next, [targetSetting.treeId, nodes, tmpTargetNode], !!targetSetting.edit.drag.next), 3071 canInner = (isCopy || !isInner) && !(targetSetting.data.keep.leaf && !tmpTargetNode.isParent) && tools.apply(targetSetting.edit.drag.inner, [targetSetting.treeId, nodes, tmpTargetNode], !!targetSetting.edit.drag.inner); 3072 3073 function clearMove() { 3074 tmpTarget = null; 3075 tmpTargetNodeId = ""; 3076 moveType = consts.move.TYPE_INNER; 3077 tmpArrow.css({ 3078 "display":"none" 3079 }); 3080 if (window.zTreeMoveTimer) { 3081 clearTimeout(window.zTreeMoveTimer); 3082 window.zTreeMoveTargetNodeTId = null 3083 } 3084 } 3085 if (!canPrev && !canNext && !canInner) { 3086 clearMove(); 3087 } else { 3088 var tmpTargetA = $("#" + tmpTargetNodeId + consts.id.A, tmpTarget), 3089 tmpNextA = tmpTargetNode.isLastNode ? null : $("#" + tmpTargetNode.getNextNode().tId + consts.id.A, tmpTarget.next()), 3090 tmpTop = tmpTargetA.offset().top, 3091 tmpLeft = tmpTargetA.offset().left, 3092 prevPercent = canPrev ? (canInner ? 0.25 : (canNext ? 0.5 : 1) ) : -1, 3093 nextPercent = canNext ? (canInner ? 0.75 : (canPrev ? 0.5 : 0) ) : -1, 3094 dY_percent = (event.clientY + docScrollTop - tmpTop)/tmpTargetA.height(); 3095 3096 if ((prevPercent==1 || dY_percent<=prevPercent && dY_percent>=-.2) && canPrev) { 3097 dX = 1 - tmpArrow.width(); 3098 dY = tmpTop - tmpArrow.height()/2; 3099 moveType = consts.move.TYPE_PREV; 3100 } else if ((nextPercent==0 || dY_percent>=nextPercent && dY_percent<=1.2) && canNext) { 3101 dX = 1 - tmpArrow.width(); 3102 dY = (tmpNextA == null || (tmpTargetNode.isParent && tmpTargetNode.open)) ? (tmpTop + tmpTargetA.height() - tmpArrow.height()/2) : (tmpNextA.offset().top - tmpArrow.height()/2); 3103 moveType = consts.move.TYPE_NEXT; 3104 } else if (canInner) { 3105 dX = 5 - tmpArrow.width(); 3106 dY = tmpTop; 3107 moveType = consts.move.TYPE_INNER; 3108 } else { 3109 clearMove(); 3110 } 3111 3112 if (tmpTarget) { 3113 tmpArrow.css({ 3114 "display":"block", 3115 "top": dY + "px", 3116 "left": (tmpLeft + dX) + "px" 3117 }); 3118 tmpTargetA.addClass(consts.node.TMPTARGET_NODE + "_" + moveType); 3119 3120 if (preTmpTargetNodeId != tmpTargetNodeId || preTmpMoveType != moveType) { 3121 startTime = (new Date()).getTime(); 3122 } 3123 if (tmpTargetNode && tmpTargetNode.isParent && moveType == consts.move.TYPE_INNER) { 3124 var startTimer = true; 3125 if (window.zTreeMoveTimer && window.zTreeMoveTargetNodeTId !== tmpTargetNode.tId) { 3126 clearTimeout(window.zTreeMoveTimer); 3127 window.zTreeMoveTargetNodeTId = null; 3128 } else if (window.zTreeMoveTimer && window.zTreeMoveTargetNodeTId === tmpTargetNode.tId) { 3129 startTimer = false;
3130 } 3131 if (startTimer) { 3132 window.zTreeMoveTimer = setTimeout(function() { 3133 if (moveType != consts.move.TYPE_INNER) return; 3134 if (tmpTargetNode && tmpTargetNode.isParent && !tmpTargetNode.open && (new Date()).getTime() - startTime > targetSetting.edit.drag.autoOpenTime 3135 && tools.apply(targetSetting.callback.beforeDragOpen, [targetSetting.treeId, tmpTargetNode], true)) { 3136 view.switchNode(targetSetting, tmpTargetNode); 3137 if (targetSetting.edit.drag.autoExpandTrigger) { 3138 targetSetting.treeObj.trigger(consts.event.EXPAND, [targetSetting.treeId, tmpTargetNode]); 3139 } 3140 } 3141 }, targetSetting.edit.drag.autoOpenTime+50); 3142 window.zTreeMoveTargetNodeTId = tmpTargetNode.tId; 3143 } 3144 } 3145 } 3146 } 3147 } else { 3148 moveType = consts.move.TYPE_INNER; 3149 if (tmpTarget && tools.apply(targetSetting.edit.drag.inner, [targetSetting.treeId, nodes, null], !!targetSetting.edit.drag.inner)) { 3150 tmpTarget.addClass(consts.node.TMPTARGET_TREE); 3151 } else { 3152 tmpTarget = null; 3153 } 3154 tmpArrow.css({ 3155 "display":"none" 3156 }); 3157 if (window.zTreeMoveTimer) { 3158 clearTimeout(window.zTreeMoveTimer); 3159 window.zTreeMoveTargetNodeTId = null; 3160 } 3161 } 3162 preTmpTargetNodeId = tmpTargetNodeId; 3163 preTmpMoveType = moveType; 3164 3165 setting.treeObj.trigger(consts.event.DRAGMOVE, [event, setting.treeId, nodes]); 3166 } 3167 return false; 3168 } 3169 3170 doc.bind("mouseup", _docMouseUp); 3171 function _docMouseUp(event) { 3172 if (window.zTreeMoveTimer) { 3173 clearTimeout(window.zTreeMoveTimer); 3174 window.zTreeMoveTargetNodeTId = null; 3175 } 3176 preTmpTargetNodeId = null; 3177 preTmpMoveType = null; 3178 doc.unbind("mousemove", _docMouseMove); 3179 doc.unbind("mouseup", _docMouseUp); 3180 doc.unbind("selectstart", _docSelect); 3181 body.css("cursor", ""); 3182 if (tmpTarget) { 3183 tmpTarget.removeClass(consts.node.TMPTARGET_TREE); 3184 if (tmpTargetNodeId) $("#" + tmpTargetNodeId + consts.id.A, tmpTarget).removeClass(consts.node.TMPTARGET_NODE + "_" + consts.move.TYPE_PREV) 3185 .removeClass(consts.node.TMPTARGET_NODE + "_" + _consts.move.TYPE_NEXT).removeClass(consts.node.TMPTARGET_NODE + "_" + _consts.move.TYPE_INNER); 3186 } 3187 tools.showIfameMask(setting, false); 3188 3189 roots.showHoverDom = true; 3190 if (root.dragFlag == 0) return; 3191 root.dragFlag = 0; 3192 3193 var i, l, tmpNode; 3194 for (i=0, l=nodes.length; i<l; i++) { 3195 tmpNode = nodes[i]; 3196 if (tmpNode.isParent && root.dragNodeShowBefore[tmpNode.tId] && !tmpNode.open) { 3197 view.expandCollapseNode(setting, tmpNode, !tmpNode.open); 3198 delete root.dragNodeShowBefore[tmpNode.tId]; 3199 } 3200 } 3201 3202 if (curNode) curNode.remove(); 3203 if (tmpArrow) tmpArrow.remove(); 3204 3205 var isCopy = ((event.ctrlKey || event.metaKey) && setting.edit.drag.isMove && setting.edit.drag.isCopy) || (!setting.edit.drag.isMove && setting.edit.drag.isCopy); 3206 if (!isCopy && tmpTarget && tmpTargetNodeId && nodes[0].parentTId && tmpTargetNodeId==nodes[0].parentTId && moveType == consts.move.TYPE_INNER) { 3207 tmpTarget = null; 3208 } 3209 if (tmpTarget) { 3210 var dragTargetNode = tmpTargetNodeId == null ? null: data.getNodeCache(targetSetting, tmpTargetNodeId); 3211 if (tools.apply(setting.callback.beforeDrop, [targetSetting.treeId, nodes, dragTargetNode, moveType, isCopy], true) == false) { 3212 view.selectNodes(sourceSetting, nodes); 3213 return; 3214 } 3215 var newNodes = isCopy ? tools.clone(nodes) : nodes; 3216 3217 function dropCallback() { 3218 if (isOtherTree) { 3219 if (!isCopy) { 3220 for(var i=0, l=nodes.length; i<l; i++) { 3221 view.removeNode(setting, nodes[i]); 3222 } 3223 } 3224 if (moveType == consts.move.TYPE_INNER) { 3225 view.addNodes(targetSetting, dragTargetNode, -1, newNodes); 3226 } else { 3227 view.addNodes(targetSetting, dragTargetNode.getParentNode(), moveType == consts.move.TYPE_PREV ? dragTargetNode.getIndex() : dragTargetNode.getIndex()+1, newNodes); 3228 } 3229 } else { 3230 if (isCopy && moveType == consts.move.TYPE_INNER) { 3231 view.addNodes(targetSetting, dragTargetNode, -1, newNodes); 3232 } else if (isCopy) { 3233 view.addNodes(targetSetting, dragTargetNode.getParentNode(), moveType == consts.move.TYPE_PREV ? dragTargetNode.getIndex() : dragTargetNode.getIndex()+1, newNodes); 3234 } else { 3235 if (moveType != consts.move.TYPE_NEXT) { 3236 for (i=0, l=newNodes.length; i<l; i++) { 3237 view.moveNode(targetSetting, dragTargetNode, newNodes[i], moveType, false); 3238 } 3239 } else { 3240 for (i=-1, l=newNodes.length-1; i<l; l--) { 3241 view.moveNode(targetSetting, dragTargetNode, newNodes[l], moveType, false); 3242 } 3243 } 3244 } 3245 } 3246 view.selectNodes(targetSetting, newNodes); 3247 3248 var a = $$(newNodes[0], setting).get(0); 3249 view.scrollIntoView(a); 3250 3251 setting.treeObj.trigger(consts.event.DROP, [event, targetSetting.treeId, newNodes, dragTargetNode, moveType, isCopy]); 3252 } 3253 3254 if (moveType == consts.move.TYPE_INNER && tools.canAsync(targetSetting, dragTargetNode)) { 3255 view.asyncNode(targetSetting, dragTargetNode, false, dropCallback); 3256 } else { 3257 dropCallback(); 3258 } 3259 3260 } else { 3261 view.selectNodes(sourceSetting, nodes); 3262 setting.treeObj.trigger(consts.event.DROP, [event, setting.treeId, nodes, null, null, null]); 3263 } 3264 } 3265 3266 doc.bind("selectstart", _docSelect); 3267 function _docSelect() { 3268 return false;
3269 } 3270 3271 //Avoid FireFox's Bug 3272 //If zTree Div CSS set 'overflow', so drag node outside of zTree, and event.target is error. 3273 if(eventMouseDown.preventDefault) { 3274 eventMouseDown.preventDefault(); 3275 } 3276 return true; 3277 } 3278 }, 3279 //method of tools for zTree 3280 _tools = { 3281 getAbs: function (obj) { 3282 var oRect = obj.getBoundingClientRect(), 3283 scrollTop = document.body.scrollTop+document.documentElement.scrollTop, 3284 scrollLeft = document.body.scrollLeft+document.documentElement.scrollLeft; 3285 return [oRect.left+scrollLeft,oRect.top+scrollTop]; 3286 }, 3287 inputFocus: function(inputObj) { 3288 if (inputObj.get(0)) { 3289 inputObj.focus(); 3290 tools.setCursorPosition(inputObj.get(0), inputObj.val().length); 3291 } 3292 }, 3293 inputSelect: function(inputObj) { 3294 if (inputObj.get(0)) { 3295 inputObj.focus(); 3296 inputObj.select(); 3297 } 3298 }, 3299 setCursorPosition: function(obj, pos){ 3300 if(obj.setSelectionRange) { 3301 obj.focus(); 3302 obj.setSelectionRange(pos,pos); 3303 } else if (obj.createTextRange) { 3304 var range = obj.createTextRange(); 3305 range.collapse(true); 3306 range.moveEnd('character', pos); 3307 range.moveStart('character', pos); 3308 range.select(); 3309 } 3310 }, 3311 showIfameMask: function(setting, showSign) { 3312 var root = data.getRoot(setting); 3313 //clear full mask 3314 while (root.dragMaskList.length > 0) { 3315 root.dragMaskList[0].remove(); 3316 root.dragMaskList.shift(); 3317 } 3318 if (showSign) { 3319 //show mask 3320 var iframeList = $$("iframe", setting); 3321 for (var i = 0, l = iframeList.length; i < l; i++) { 3322 var obj = iframeList.get(i), 3323 r = tools.getAbs(obj), 3324 dragMask = $$("<div id='zTreeMask_" + i + "' class='zTreeMask' style='top:" + r[1] + "px; left:" + r[0] + "px; width:" + obj.offsetWidth + "px; height:" + obj.offsetHeight + "px;'></div>", setting); 3325 dragMask.appendTo($$("body", setting)); 3326 root.dragMaskList.push(dragMask); 3327 } 3328 } 3329 } 3330 }, 3331 //method of operate ztree dom 3332 _view = { 3333 addEditBtn: function(setting, node) { 3334 if (node.editNameFlag || $$(node, consts.id.EDIT, setting).length > 0) { 3335 return; 3336 } 3337 if (!tools.apply(setting.edit.showRenameBtn, [setting.treeId, node], setting.edit.showRenameBtn)) { 3338 return; 3339 } 3340 var aObj = $$(node, consts.id.A, setting), 3341 editStr = "<span class='" + consts.className.BUTTON + " edit' id='" + node.tId + consts.id.EDIT + "' title='"+tools.apply(setting.edit.renameTitle, [setting.treeId, node], setting.edit.renameTitle)+"' treeNode"+consts.id.EDIT+" style='display:none;'></span>"; 3342 aObj.append(editStr); 3343 3344 $$(node, consts.id.EDIT, setting).bind('click', 3345 function() { 3346 if (!tools.uCanDo(setting) || tools.apply(setting.callback.beforeEditName, [setting.treeId, node], true) == false) return false; 3347 view.editNode(setting, node); 3348 return false; 3349 } 3350 ).show(); 3351 }, 3352 addRemoveBtn: function(setting, node) { 3353 if (node.editNameFlag || $$(node, consts.id.REMOVE, setting).length > 0) { 3354 return; 3355 } 3356 if (!tools.apply(setting.edit.showRemoveBtn, [setting.treeId, node], setting.edit.showRemoveBtn)) { 3357 return; 3358 } 3359 var aObj = $$(node, consts.id.A, setting), 3360 removeStr = "<span class='" + consts.className.BUTTON + " remove' id='" + node.tId + consts.id.REMOVE + "' title='"+tools.apply(setting.edit.removeTitle, [setting.treeId, node], setting.edit.removeTitle)+"' treeNode"+consts.id.REMOVE+" style='display:none;'></span>"; 3361 aObj.append(removeStr); 3362 3363 $$(node, consts.id.REMOVE, setting).bind('click', 3364 function() { 3365 if (!tools.uCanDo(setting) || tools.apply(setting.callback.beforeRemove, [setting.treeId, node], true) == false) return false; 3366 view.removeNode(setting, node); 3367 setting.treeObj.trigger(consts.event.REMOVE, [setting.treeId, node]); 3368 return false; 3369 } 3370 ).bind('mousedown', 3371 function(eventMouseDown) { 3372 return true; 3373 } 3374 ).show(); 3375 }, 3376 addHoverDom: function(setting, node) { 3377 if (data.getRoots().showHoverDom) { 3378 node.isHover = true; 3379 if (setting.edit.enable) { 3380 view.addEditBtn(setting, node); 3381 view.addRemoveBtn(setting, node); 3382 } 3383 tools.apply(setting.view.addHoverDom, [setting.treeId, node]); 3384 } 3385 }, 3386 cancelCurEditNode: function (setting, forceName, isCancel) { 3387 var root = data.getRoot(setting), 3388 nameKey = setting.data.key.name, 3389 node = root.curEditNode; 3390 3391 if (node) { 3392 var inputObj = root.curEditInput, 3393 newName = forceName ? forceName:(isCancel ? node[nameKey]: inputObj.val()); 3394 if (tools.apply(setting.callback.beforeRename, [setting.treeId, node, newName, isCancel], true) === false) { 3395 return false;
3396 } 3397 node[nameKey] = newName; 3398 var aObj = $$(node, consts.id.A, setting); 3399 aObj.removeClass(consts.node.CURSELECTED_EDIT); 3400 inputObj.unbind(); 3401 view.setNodeName(setting, node); 3402 node.editNameFlag = false; 3403 root.curEditNode = null; 3404 root.curEditInput = null; 3405 view.selectNode(setting, node, false); 3406 setting.treeObj.trigger(consts.event.RENAME, [setting.treeId, node, isCancel]); 3407 } 3408 root.noSelection = true; 3409 return true; 3410 }, 3411 editNode: function(setting, node) { 3412 var root = data.getRoot(setting); 3413 view.editNodeBlur = false; 3414 if (data.isSelectedNode(setting, node) && root.curEditNode == node && node.editNameFlag) { 3415 setTimeout(function() {tools.inputFocus(root.curEditInput);}, 0); 3416 return; 3417 } 3418 var nameKey = setting.data.key.name; 3419 node.editNameFlag = true; 3420 view.removeTreeDom(setting, node); 3421 view.cancelCurEditNode(setting); 3422 view.selectNode(setting, node, false); 3423 $$(node, consts.id.SPAN, setting).html("<input type=text class='rename' id='" + node.tId + consts.id.INPUT + "' treeNode" + consts.id.INPUT + " >"); 3424 var inputObj = $$(node, consts.id.INPUT, setting); 3425 inputObj.attr("value", node[nameKey]); 3426 if (setting.edit.editNameSelectAll) { 3427 tools.inputSelect(inputObj); 3428 } else { 3429 tools.inputFocus(inputObj); 3430 } 3431 3432 inputObj.bind('blur', function(event) { 3433 if (!view.editNodeBlur) { 3434 view.cancelCurEditNode(setting); 3435 } 3436 }).bind('keydown', function(event) { 3437 if (event.keyCode=="13") { 3438 view.editNodeBlur = true; 3439 view.cancelCurEditNode(setting); 3440 } else if (event.keyCode=="27") { 3441 view.cancelCurEditNode(setting, null, true); 3442 } 3443 }).bind('click', function(event) { 3444 return false; 3445 }).bind('dblclick', function(event) { 3446 return false; 3447 }); 3448 3449 $$(node, consts.id.A, setting).addClass(consts.node.CURSELECTED_EDIT); 3450 root.curEditInput = inputObj; 3451 root.noSelection = false; 3452 root.curEditNode = node; 3453 }, 3454 moveNode: function(setting, targetNode, node, moveType, animateFlag, isSilent) { 3455 var root = data.getRoot(setting), 3456 childKey = setting.data.key.children; 3457 if (targetNode == node) return; 3458 if (setting.data.keep.leaf && targetNode && !targetNode.isParent && moveType == consts.move.TYPE_INNER) return; 3459 var oldParentNode = (node.parentTId ? node.getParentNode(): root), 3460 targetNodeIsRoot = (targetNode === null || targetNode == root); 3461 if (targetNodeIsRoot && targetNode === null) targetNode = root; 3462 if (targetNodeIsRoot) moveType = consts.move.TYPE_INNER; 3463 var targetParentNode = (targetNode.parentTId ? targetNode.getParentNode() : root); 3464 3465 if (moveType != consts.move.TYPE_PREV && moveType != consts.move.TYPE_NEXT) { 3466 moveType = consts.move.TYPE_INNER; 3467 } 3468 3469 if (moveType == consts.move.TYPE_INNER) { 3470 if (targetNodeIsRoot) { 3471 //parentTId of root node is null 3472 node.parentTId = null; 3473 } else { 3474 if (!targetNode.isParent) { 3475 targetNode.isParent = true; 3476 targetNode.open = !!targetNode.open; 3477 view.setNodeLineIcos(setting, targetNode); 3478 } 3479 node.parentTId = targetNode.tId; 3480 } 3481 } 3482 3483 //move node Dom 3484 var targetObj, target_ulObj; 3485 if (targetNodeIsRoot) { 3486 targetObj = setting.treeObj; 3487 target_ulObj = targetObj; 3488 } else { 3489 if (!isSilent && moveType == consts.move.TYPE_INNER) { 3490 view.expandCollapseNode(setting, targetNode, true, false); 3491 } else if (!isSilent) { 3492 view.expandCollapseNode(setting, targetNode.getParentNode(), true, false); 3493 } 3494 targetObj = $$(targetNode, setting); 3495 target_ulObj = $$(targetNode, consts.id.UL, setting); 3496 if (!!targetObj.get(0) && !target_ulObj.get(0)) { 3497 var ulstr = []; 3498 view.makeUlHtml(setting, targetNode, ulstr, ''); 3499 targetObj.append(ulstr.join('')); 3500 } 3501 target_ulObj = $$(targetNode, consts.id.UL, setting); 3502 } 3503 var nodeDom = $$(node, setting); 3504 if (!nodeDom.get(0)) { 3505 nodeDom = view.appendNodes(setting, node.level, [node], null, -1, false, true).join(''); 3506 } else if (!targetObj.get(0)) { 3507 nodeDom.remove(); 3508 } 3509 if (target_ulObj.get(0) && moveType == consts.move.TYPE_INNER) { 3510 target_ulObj.append(nodeDom); 3511 } else if (targetObj.get(0) && moveType == consts.move.TYPE_PREV) { 3512 targetObj.before(nodeDom); 3513 } else if (targetObj.get(0) && moveType == consts.move.TYPE_NEXT) { 3514 targetObj.after(nodeDom); 3515 } 3516 3517 //repair the data after move 3518 var i,l, 3519 tmpSrcIndex = -1, 3520 tmpTargetIndex = 0, 3521 oldNeighbor = null, 3522 newNeighbor = null, 3523 oldLevel = node.level; 3524 if (node.isFirstNode) { 3525 tmpSrcIndex = 0; 3526 if (oldParentNode[childKey].length > 1 ) { 3527 oldNeighbor = oldParentNode[childKey][1]; 3528 oldNeighbor.isFirstNode = true; 3529 } 3530 } else if (node.isLastNode) { 3531 tmpSrcIndex = oldParentNode[childKey].length -1; 3532 oldNeighbor = oldParentNode[childKey][tmpSrcIndex - 1]; 3533 oldNeighbor.isLastNode = true; 3534 } else { 3535 for (i = 0, l = oldParentNode[childKey].length; i < l; i++) { 3536 if (oldParentNode[childKey][i].tId == node.tId) { 3537 tmpSrcIndex = i; 3538 break; 3539 } 3540 } 3541 } 3542 if (tmpSrcIndex >= 0) { 3543 oldParentNode[childKey].splice(tmpSrcIndex, 1); 3544 } 3545 if (moveType != consts.move.TYPE_INNER) { 3546 for (i = 0, l = targetParentNode[childKey].length; i < l; i++) { 3547 if (targetParentNode[childKey][i].tId == targetNode.tId) tmpTargetIndex = i; 3548 } 3549 } 3550 if (moveType == consts.move.TYPE_INNER) { 3551 if (!targetNode[childKey]) targetNode[childKey] = new Array(); 3552 if (targetNode[childKey].length > 0) { 3553 newNeighbor = targetNode[childKey][targetNode[childKey].length - 1]; 3554 newNeighbor.isLastNode = false;
3555 } 3556 targetNode[childKey].splice(targetNode[childKey].length, 0, node); 3557 node.isLastNode = true; 3558 node.isFirstNode = (targetNode[childKey].length == 1); 3559 } else if (targetNode.isFirstNode && moveType == consts.move.TYPE_PREV) { 3560 targetParentNode[childKey].splice(tmpTargetIndex, 0, node); 3561 newNeighbor = targetNode; 3562 newNeighbor.isFirstNode = false; 3563 node.parentTId = targetNode.parentTId; 3564 node.isFirstNode = true; 3565 node.isLastNode = false; 3566 3567 } else if (targetNode.isLastNode && moveType == consts.move.TYPE_NEXT) { 3568 targetParentNode[childKey].splice(tmpTargetIndex + 1, 0, node); 3569 newNeighbor = targetNode; 3570 newNeighbor.isLastNode = false; 3571 node.parentTId = targetNode.parentTId; 3572 node.isFirstNode = false; 3573 node.isLastNode = true; 3574 3575 } else { 3576 if (moveType == consts.move.TYPE_PREV) { 3577 targetParentNode[childKey].splice(tmpTargetIndex, 0, node); 3578 } else { 3579 targetParentNode[childKey].splice(tmpTargetIndex + 1, 0, node); 3580 } 3581 node.parentTId = targetNode.parentTId; 3582 node.isFirstNode = false; 3583 node.isLastNode = false; 3584 } 3585 data.fixPIdKeyValue(setting, node); 3586 data.setSonNodeLevel(setting, node.getParentNode(), node); 3587 3588 //repair node what been moved 3589 view.setNodeLineIcos(setting, node); 3590 view.repairNodeLevelClass(setting, node, oldLevel) 3591 3592 //repair node's old parentNode dom 3593 if (!setting.data.keep.parent && oldParentNode[childKey].length < 1) { 3594 //old parentNode has no child nodes 3595 oldParentNode.isParent = false; 3596 oldParentNode.open = false; 3597 var tmp_ulObj = $$(oldParentNode, consts.id.UL, setting), 3598 tmp_switchObj = $$(oldParentNode, consts.id.SWITCH, setting), 3599 tmp_icoObj = $$(oldParentNode, consts.id.ICON, setting); 3600 view.replaceSwitchClass(oldParentNode, tmp_switchObj, consts.folder.DOCU); 3601 view.replaceIcoClass(oldParentNode, tmp_icoObj, consts.folder.DOCU); 3602 tmp_ulObj.css("display", "none"); 3603 3604 } else if (oldNeighbor) { 3605 //old neigbor node 3606 view.setNodeLineIcos(setting, oldNeighbor); 3607 } 3608 3609 //new neigbor node 3610 if (newNeighbor) { 3611 view.setNodeLineIcos(setting, newNeighbor); 3612 } 3613 3614 //repair checkbox / radio 3615 if (!!setting.check && setting.check.enable && view.repairChkClass) { 3616 view.repairChkClass(setting, oldParentNode); 3617 view.repairParentChkClassWithSelf(setting, oldParentNode); 3618 if (oldParentNode != node.parent) 3619 view.repairParentChkClassWithSelf(setting, node); 3620 } 3621 3622 //expand parents after move 3623 if (!isSilent) { 3624 view.expandCollapseParentNode(setting, node.getParentNode(), true, animateFlag); 3625 } 3626 }, 3627 removeEditBtn: function(setting, node) { 3628 $$(node, consts.id.EDIT, setting).unbind().remove(); 3629 }, 3630 removeRemoveBtn: function(setting, node) { 3631 $$(node, consts.id.REMOVE, setting).unbind().remove(); 3632 }, 3633 removeTreeDom: function(setting, node) { 3634 node.isHover = false; 3635 view.removeEditBtn(setting, node); 3636 view.removeRemoveBtn(setting, node); 3637 tools.apply(setting.view.removeHoverDom, [setting.treeId, node]); 3638 }, 3639 repairNodeLevelClass: function(setting, node, oldLevel) { 3640 if (oldLevel === node.level) return; 3641 var liObj = $$(node, setting), 3642 aObj = $$(node, consts.id.A, setting), 3643 ulObj = $$(node, consts.id.UL, setting), 3644 oldClass = consts.className.LEVEL + oldLevel, 3645 newClass = consts.className.LEVEL + node.level; 3646 liObj.removeClass(oldClass); 3647 liObj.addClass(newClass); 3648 aObj.removeClass(oldClass); 3649 aObj.addClass(newClass); 3650 ulObj.removeClass(oldClass); 3651 ulObj.addClass(newClass); 3652 }, 3653 selectNodes : function(setting, nodes) { 3654 for (var i=0, l=nodes.length; i<l; i++) { 3655 view.selectNode(setting, nodes[i], i>0); 3656 } 3657 } 3658 }, 3659 3660 _z = { 3661 tools: _tools, 3662 view: _view, 3663 event: _event, 3664 data: _data 3665 }; 3666 $.extend(true, $.fn.zTree.consts, _consts); 3667 $.extend(true, $.fn.zTree._z, _z); 3668 3669 var zt = $.fn.zTree, 3670 tools = zt._z.tools, 3671 consts = zt.consts, 3672 view = zt._z.view, 3673 data = zt._z.data, 3674 event = zt._z.event, 3675 $$ = tools.$; 3676 3677 data.exSetting(_setting); 3678 data.addInitBind(_bindEvent); 3679 data.addInitUnBind(_unbindEvent); 3680 data.addInitCache(_initCache); 3681 data.addInitNode(_initNode); 3682 data.addInitProxy(_eventProxy); 3683 data.addInitRoot(_initRoot); 3684 data.addZTreeTools(_zTreeTools); 3685 3686 var _cancelPreSelectedNode = view.cancelPreSelectedNode; 3687 view.cancelPreSelectedNode = function (setting, node) { 3688 var list = data.getRoot(setting).curSelectedList; 3689 for (var i=0, j=list.length; i<j; i++) { 3690 if (!node || node === list[i]) { 3691 view.removeTreeDom(setting, list[i]); 3692 if (node) break; 3693 } 3694 } 3695 if (_cancelPreSelectedNode) _cancelPreSelectedNode.apply(view, arguments); 3696 } 3697 3698 var _createNodes = view.createNodes; 3699 view.createNodes = function(setting, level, nodes, parentNode, index) { 3700 if (_createNodes) { 3701 _createNodes.apply(view, arguments); 3702 }
3703 if (!nodes) return; 3704 if (view.repairParentChkClassWithSelf) { 3705 view.repairParentChkClassWithSelf(setting, parentNode); 3706 } 3707 } 3708 3709 var _makeNodeUrl = view.makeNodeUrl; 3710 view.makeNodeUrl = function(setting, node) { 3711 return setting.edit.enable ? null : (_makeNodeUrl.apply(view, arguments)); 3712 } 3713 3714 var _removeNode = view.removeNode; 3715 view.removeNode = function(setting, node) { 3716 var root = data.getRoot(setting); 3717 if (root.curEditNode === node) root.curEditNode = null; 3718 if (_removeNode) { 3719 _removeNode.apply(view, arguments); 3720 } 3721 } 3722 3723 var _selectNode = view.selectNode; 3724 view.selectNode = function(setting, node, addFlag) { 3725 var root = data.getRoot(setting); 3726 if (data.isSelectedNode(setting, node) && root.curEditNode == node && node.editNameFlag) { 3727 return false; 3728 } 3729 if (_selectNode) _selectNode.apply(view, arguments); 3730 view.addHoverDom(setting, node); 3731 return true; 3732 } 3733 3734 var _uCanDo = tools.uCanDo; 3735 tools.uCanDo = function(setting, e) { 3736 var root = data.getRoot(setting); 3737 if (e && (tools.eqs(e.type, "mouseover") || tools.eqs(e.type, "mouseout") || tools.eqs(e.type, "mousedown") || tools.eqs(e.type, "mouseup"))) { 3738 return true; 3739 } 3740 if (root.curEditNode) { 3741 view.editNodeBlur = false; 3742 root.curEditInput.focus(); 3743 } 3744 return (!root.curEditNode) && (_uCanDo ? _uCanDo.apply(view, arguments) : true); 3745 } 3746})(jQuery);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.