openo-portal/portal-common/src/main/webapp/common/thirdparty/zTree/js/jquery.ztree.all.js

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