<!-- Beginning hidden

var Tree = function(myName) {  // 创建“树对象”。其中，myName 是该对象的名。可在此后用“myName”来调用之。

      var help = function() {           // 显示帮助页面
            var attrString = "top=0,left=10,width=1000,height=600,toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes";
            window.open("doc/directoryTree.txt", "", attrString);
      }
//============== 下面开始建立树对象 ============================

      myName = (myName==null?"":myName.trim());
      if (myName!="" && eval("self."+myName)) {alert(myName + "已经存在，请换一个名"); return null;}
      if (myName=="") {help(); return null;}

      var tree_obj = new Object();
      tree_obj.name = myName;                                  // 树对象的名
      tree_obj.help = help;                                    // “帮助”的方法
      tree_obj.nodes = new Array();                            // 所有非根节点
      tree_obj.currentNode = null;                             // 当前节点
      tree_obj.creater = ParameterSetCreater();                // 参数集生成器
//------------ 建立基本参数集 -----------------------------
      tree_obj.basicParameters = tree_obj.creater.create(
              "generalColor      = #000000     "     // 普通节点的颜色
            , "currentColor      = #000000     "     // 当前节点的颜色
            , "generalBgColor    = #EEF7FF     "     // 普通节点的底色
            , "currentBgColor    = #a0a0a0     "     // 当前节点的底色
            , "textIndent        = 6           "     // 节点文字的缩进
            , "imageDirectory    = treeImages/ "     // 图符文件目录
            , "checkRepeat       = false       "     // 加节点时是否检查同名节点的存在
      );
//------------ 建立图标参数集 -----------------------------
      tree_obj.iconParameters = tree_obj.creater.create(
                    "│         = icon_vert_line.gif     "     // 形如“┃”的垂直连线
                  , "├ +       = icon_plus_cont.gif     "     // 收拢之文件夹节点的、形如“┣”的加形图符
                  , "└ +       = icon_plus_end.gif      "     // 收拢之终结文件夹节点的、形如“┗”的加形图符
                  , "├ -       = icon_minus_cont.gif    "     // 展开之文件夹节点的、形如“┣”的减形图符
                  , "└ -       = icon_minus_end.gif     "     // 展开之终结文件夹节点的、形如“┗”的减形图符
                  , "├         = icon_branch_cont.gif   "     // 叶子节点的、形如“┣”的连线图符
                  , "└         = icon_branch_end.gif    "     // 终结叶子节点的、形如“┗”的连线图符
                  , "root       = root1.gif          "     // 根节点图标
                  , "leaf       = tag1.gif          "     // 叶子图标
                  , "folder     = folder_close1.gif  "     // 文件夹（闭合）图标
                  , "folderOpen = folder_open1.gif   "     // 展开文件夹的图标
      );
      tree_obj.iconParameters.appendable = false;             // 图标参数接收器中，不可再添加其它不知名的属性
//------------ 建立事件参数集 -----------------------------
      tree_obj.eventParameters = tree_obj.creater.create(     // 元素/动作 = 调用函数名（其参数是节点在nodes数组中的下标）
                     "getSon         =             "          // 展开时如无子节点，则将调用的函数
                   , "con/click      = this.hit_con"          // 点击节点的加减号连接线图标：展开或收拢，但不高亮显示当前节点。
                   , "icon/click     = this.hit_icon"         // 点击节点图标：未展开的则展开；并进行“text/click”的动作。
                   , "checkbox/click = this.hit_checkBox"     // 点击节点检查盒：同步设置下层节点的检查盒。
                   , "text/click     = this.hit_text"         // 点击节点文字：高亮显示当前节点。
                   , "text/dblclick  = "                      // 双点节点文字：无动作。
      );
//      tree_obj.eventParameters.appendable = false;            // 事件参数接收器中，不可再添加其它不知名的属性
//------------ 建立根节点 -----------------------------
      tree_obj.root = new Object();                           // 根节点
      tree_obj.root.parameters = tree_obj.creater.create(     // 节点参数集
                   "text       = 根节点 "      // 根节点的显示文字
                 , "isHidden   = false "       // 根节点是否不显示
                 , "folder     = "             // 文件夹（闭合）图标
                 , "folderOpen = "             // 展开文件夹的图标
                 , "type       = 2 "           // 根节点类型（0——叶子；1——收拢文件夹；2——展开文件夹）
                 , "checkbox   = 1 "           // 根节点检查盒的状态（0——没有；1——有，可用；2——有，不可用）
                 , "isChecked  = false"        // 根节点检查盒是否被选中。缺省不选中。
                 , "tip        = "             // 鼠标置上时显示的标签文字
      );
      tree_obj.root.element     = null;            // HTML 元素
      tree_obj.root.parentNode  = null;            // 父节点
      tree_obj.root.isExpand    = false;           // 本节点是否已展开
      tree_obj.root.isLast      = true;            // 节点是否是本层的最后一个节点
      tree_obj.root.isHighLight = false;           // 当前是否高亮
      tree_obj.root.isDeleted   = false;           // 节点是否已被删除
      tree_obj.root.isChecked   = false;           // 节点检查盒是否被选中
      tree_obj.root.index       = -1;              // 根节点不在 nodes 数组中
      tree_obj.root.subNodes    = new Array();     // 根节点的子节点数组
      tree_obj.icons            = new Array();     // 图标对象集

//============ 内部函数 ====================

      tree_obj.getIcon = function(fn) {
            if (fn==null || fn=="") {return "";}
            for (var i=0; i<this.icons.length; i++) {
                  if (this.icons[i].fileName==fn) {return this.icons[i].image.src;}
            }
            var img_obj = new Object();
            img_obj.fileName = fn;
            img_obj.image = new Image();
            img_obj.image.src = this.basicParameters.getValue("imageDirectory") + fn;
            this.icons[this.icons.length] = img_obj;
            return img_obj.image.src;
      }
      tree_obj.setEvents = function(eleName, e, n) {
            var hasAction = false;
            var ss;
            for (var i=0; i<this.eventParameters.attributes.length; i++) {
                  if (this.eventParameters.attributes[i].value != "") {
                        ss = this.eventParameters.attributes[i].name.split("/");
                        if (ss.length==2 && ss[0]==eleName) {
                              eval("e.on"+ss[1]+"= new Function(\""+this.name + ".eventProcess('"+eleName+"/"+ss[1]+"', " + n +");\");");
                              hasAction = true;
                        }
                  }
            }
            if (hasAction) {e.style.cursor = 'hand';}
      }
      tree_obj.eventProcess = function(e_e, n) {
            var functionName = this.eventParameters.getValue(e_e);
            if (functionName!="") {eval(functionName+"("+n+")");}
      }
      tree_obj.hit_con = function(n) {       // 点击节点的加减号连接线图标。根据原展开/收拢状态切换之，但不高亮显示当前节点。
            var node = this.getNode(n);
            var node_type = node.parameters.getInteger("type");
            if (node_type!=0) {
                  if (node_type==1) {this.expand(node);}
                  else {this.collapse(node);}
            }
      }
      tree_obj.hit_text = function(n) {      // 点击节点文字。高亮显示当前节点。
            var node = this.getNode(n);
            this.setHighLight(node, "isHighLight=true", "isClearOldHighLight=true", "isCurrent=true");
      }
      tree_obj.hit_icon = function(n) {      // 点击节点图标。如果未展开，则展开之；并进行点击文字时的动作。
            var node = this.getNode(n);
            if (node.parameters.getInteger("type")==1) {this.expand(node);}
            this.eventProcess("text/click", n);
      }
      tree_obj.hit_checkBox = function(n) {  // 点击节点检查盒。同步设置下层节点的检查盒。
            var node = this.getNode(n);
            var node_checkbox = this.getNodeCheckbox(node);
            b = node_checkbox.checked;
            this.resetCheckBox(node, b);
      }
      tree_obj.drawNode = function(node) {    // 画加节点
            for (var i=0; i<node.parentNode.subNodes.length; i++) {    // 将之前的最后节点置为非最后节点。
                  if (node.parentNode.subNodes[i].index==node.index) {break;}
                  else {if (node.parentNode.subNodes[i].isLast && !node.parentNode.subNodes[i].isDeleted) {
                              node.parentNode.subNodes[i].isLast = false;
                              this.setConIcon(node.parentNode.subNodes[i]);
                        }
                  }
            }
            if (node.parentNode.parameters.getInteger("type")==2) {
                  node.parentNode.element.rows[1].style.display = "block";
            }
            var sonsTable = node.parentNode.element.rows[1].cells[1].children[0];              // 子节点的集合
            var rowNo = sonsTable.rows.length;
            sonsTable.insertRow(rowNo);         // 为加入的节点插入一行
            sonsTable.rows[rowNo].style.verticalAlign = "top";
            sonsTable.rows[rowNo].style.display = "block";
            sonsTable.rows[rowNo].insertCell();                                          // 插入一列
            sonsTable.rows[rowNo].cells[0].style.textAlign="left";
//            sonsTable.rows[rowNo].cells[0].noWrap = true;

            node.element = document.createElement('table');         // 节点
            sonsTable.rows[rowNo].cells[0].appendChild(node.element);
            node.element.nodeIndex = node.index;        // nodes 数组中的下标
            node.isLast            = true;              // 本节点是否是本层的最后一个节点

            node.element.cellPadding = 0;
            node.element.cellSpacing = 0;
            node.element.border = 0;
            node.element.style.backgroundColor = this.basicParameters.getValue("generalBgColor");
            node.element.insertRow(0);                          // 第1行放节点的加减号连接线和图标、检查盒及文字
            node.element.rows[0].style.verticalAlign = "top";
            node.element.rows[0].insertCell();                     // 第1列放加减号连接线
            node.element.rows[0].insertCell();                     // 第2列放图标和文字
            node.element.insertRow(1);                          // 第2行放子节点
            node.element.rows[1].style.verticalAlign = "top";
            node.element.rows[1].insertCell();                     // 第1列放竖线
            node.element.rows[1].insertCell();                     // 第2列放子节点
//-------- 第1行第1列 ----------------
            node.element.rows[0].cells[0].appendChild(document.createElement('img'));         // 节点的加减号连接线图标
            node.element.rows[0].cells[0].width = 10;
//-------- 第1行第2列 ----------------
            var showTable = document.createElement('table');                     // 节点的显示 TABLE
            node.element.rows[0].cells[1].appendChild(showTable);
            showTable.cellPadding = 0;
            showTable.cellSpacing = 0;
            showTable.border = 0;
            showTable.style.backgroundColor = this.basicParameters.getValue("generalBgColor");
            showTable.insertRow(0);
            showTable.rows[0].style.verticalAlign = "middle";
            showTable.rows[0].insertCell();    // 放节点的加减号连接线文字
            showTable.rows[0].insertCell();    // 放节点的图标（包括：文字型图标）
            showTable.rows[0].insertCell();    // 放节点的检查盒
            showTable.rows[0].insertCell();    // 放节点的文字
            showTable.rows[0].cells[1].appendChild(document.createElement('img'));        // 节点的图标
            showTable.rows[0].cells[1].appendChild(document.createElement('span'));       // 节点的文字型图标
            showTable.rows[0].cells[2].innerHTML = "<input type='checkbox'>";             // 节点的检查盒
            showTable.rows[0].cells[3].noWrap = true;                                     // 节点的文字
            showTable.rows[0].cells[3].style.verticalAlign = "middle";
            showTable.rows[0].cells[3].style.textIndent = this.basicParameters.getInteger("textIndent");
            showTable.rows[0].cells[3].style.backgroundColor = this.basicParameters.getValue("generalBgColor");
            showTable.rows[0].cells[3].style.color           = this.basicParameters.getValue("generalColor");
            showTable.rows[0].cells[3].innerHTML = node.parameters.getValue("text");      // 显示文字
            showTable.rows[0].cells[3].title = node.parameters.getValue("tip");           // 鼠标置上时显示的标签文字
//-------- 第2行第1列 ----------------

//-------- 第2行第2列 ----------------
            node.element.rows[1].cells[1].appendChild(document.createElement('table'));          // 子节点的集合
            node.element.rows[1].cells[1].children[0].cellPadding = 0;
            node.element.rows[1].cells[1].children[0].cellSpacing = 0;
            node.element.rows[1].cells[1].children[0].border = 0;
            node.element.rows[1].style.display = (node.parameters.getInteger("type")==2?"block":"none"); // 子节点的展开收拢帧

            this.setNode(node, true);
            if (node.parameters.getInteger("type")==2) {
                  node.isExpand = true;
                  for (var i=0; i<node.subNodes.length; i++) {this.drawNode(node.subNodes[i]);}
            }
      }
      tree_obj.setNode = function(node, onlyCurrent) {  // 设置节点。（是否包括下层节点；缺省：包括）
            var e;
            e = node.element.rows[0].cells[0].children[0];              // 节点的加减号连接线图标
            e.border = 0;
            e.align = "absmiddle";
            this.setEvents("con", e, node.index);

            e = node.element.rows[0].cells[1].children[0].rows[0].cells[0];                // 节点的加减号连接线文字
            this.setEvents("con", e, node.index);

            e = node.element.rows[0].cells[1].children[0].rows[0].cells[2].children[0];    // 节点的检查盒
            e.checked = node.isChecked;
            if (node.parameters.getInteger("checkbox")==0) {e.style.display = "none";}
            else {e.style.display = "block";
                  e.disabled = (node.parameters.getInteger("checkbox")==2?true:false);
            }
            this.setEvents("checkbox", e, node.index);

            e = node.element.rows[0].cells[1].children[0].rows[0].cells[3];                // 节点的文字
            this.setEvents("text", e, node.index);

            e = node.element.rows[0].cells[1].children[0].rows[0].cells[1].children[0];    // 节点的图标
            e.border = 0;
            e.align = "absmiddle";
            this.setEvents("icon", e, node.index);

            e = node.element.rows[0].cells[1].children[0].rows[0].cells[1].children[1];    // 节点的文字型图标
            this.setEvents("icon", e, node.index);

            var node_type = node.parameters.getInteger("type");            // 节点类型
            var fn;                                                        // 图片文件名
            var isRoot = (node.parentNode==null?true:false);               // 是否根节点
            var icon = this.getNodeIcon(node);                             // 节点的图标
            var text = this.getNodeIcon2(node);                            // 节点的文字型图标
//            this.getIcon(node.parameters.getValue("leaf"));
//            this.getIcon(node.parameters.getValue("folder"));
//            this.getIcon(node.parameters.getValue("folderOpen"));
            if (isRoot || node_type!=0) {                       // 根节点或文件夹节点
                  if (node_type==1) {                    // 是收拢文件夹
                        fn = node.parameters.getValue("folder");
                        if (fn == "") {fn = this.iconParameters.getValue((isRoot?"root":"folder"));}
                        if (fn == "") {
                              icon.style.display = "none";
                              text.style.display = "block";
                              text.innerText = "□ ";
                        }
                        else {icon.style.display = "block";
                              text.style.display = "none";
                              icon.src = this.getIcon(fn);
                        }
                  }
                  else {fn = node.parameters.getValue("folderOpen");
                        if (fn == "") {fn = this.iconParameters.getValue((isRoot?"root":"folderOpen"));}
                        if (fn == "") {
                              icon.style.display = "none";
                              text.style.display = "block";
                              text.innerText = "■ ";
                        }
                        else {icon.style.display = "block";
                              text.style.display = "none";
                              icon.src = this.getIcon(fn);
                        }
                  }
                  if (isRoot) {
                        icon = this.getNodeCon(node);           // 节点的加减号连接线图标
                        text = this.getNodeCon2(node);          // 节点的加减号连接线文字
                        icon.style.display = "none";            // 根节点的连接线总是不显示
                        text.style.display = "none";            // 根节点的连接线总是不显示
                  }
                  else {this.setConIcon(node);}             // 根据是否是最后一个节点，设置连接线、竖线
            }
            else {fn = node.parameters.getValue("leaf");
                  if (fn == "") {fn = this.iconParameters.getValue("leaf");}
                  if (fn == "") {
                        icon.style.display = "none";
                        text.style.display = "block";
                        text.innerText = " ";
                  }
                  else {icon.style.display = "block";
                        text.style.display = "none";
                        icon.src = this.getIcon(fn);
                  }
                  this.setConIcon(node);             // 根据是否是最后一个节点，设置连接线、竖线
            }
            if (!onlyCurrent && node.isExpand) {
                  e = node.element.rows[1].cells[1].children[0];              // 子节点的集合
                  var subNode;
                  for (var i=0; i<e.rows.length; i++) {
                        subNode = this.nodes[e.rows[i].cells[0].children[0].nodeIndex];
                        subNode.element = e.rows[i].cells[0].children[0];
                        this.setNode(subNode, false);
                  }
            }
      }
      tree_obj.setConIcon = function(node) {            // 根据是否是最后一个节点，设置连接线、竖线
            var icon = this.getNodeCon(node);           // 节点的加减号连接线图标
            var text = this.getNodeCon2(node);          // 节点的加减号连接线文字
            var vert = node.element.rows[1].cells[0];   // 上层节点的跨接竖线图标
            var node_type = node.parameters.getInteger("type");            // 节点类型
            var fn;                                                        // 图片文件名
            var path = this.basicParameters.getValue("imageDirectory");    // 图片文件夹路径
            var isRoot = (node.parentNode==null?true:false);               // 是否根节点
            if (node.isLast) {
                  icon.alt = "└";
                  vert.style.backgroundImage = "";
            }
            else {icon.alt = "├";
                  fn = this.iconParameters.getValue("│");
                  if (fn != "") {       // 连线图标存在
                        vert.style.backgroundImage = "url(" + this.getIcon(fn) + ")";
                  }
            }
            text.innerText = "　";
            if (node_type==0) {                           // 是叶子
                  if (node.isLast) {
                        fn = this.iconParameters.getValue("└");
                        if (fn=="") {
                              icon.style.display = "none";
                              text.style.display = "block";
                        }
                        else {icon.style.display = "block";
                              text.style.display = "none";
                              icon.src = this.getIcon(fn);
                        }
                  }
                  else {fn = this.iconParameters.getValue("├");
                        if (fn=="") {
                              icon.style.display = "none";
                              text.style.display = "block";
                        }
                        else {icon.style.display = "block";
                              text.style.display = "none";
                              icon.src = this.getIcon(fn);
                        }
                  }
            }
            else {icon.style.display = "none";
                  text.style.display = "none";
                  if (node_type==1) {                           // 是收拢文件夹
                        text.innerText = "╋";
                        if (node.isLast) {
                              fn = this.iconParameters.getValue("└ +");
                              if (fn != "") {icon.src = this.getIcon(fn);}
                        }
                        else {fn = this.iconParameters.getValue("├ +");
                              if (fn != "") {icon.src = this.getIcon(fn);}
                        }
                  }
                  else {text.innerText = "━";
                        if (node.isLast) {
                              fn = this.iconParameters.getValue("└ -");
                              if (fn != "") {icon.src = this.getIcon(fn);}
                        }
                        else {fn = this.iconParameters.getValue("├ -");
                              if (fn != "") {icon.src = this.getIcon(fn);}
                        }
                  }
                  if (icon.src) {icon.style.display = "block";}
                  else {if (!icon.src) text.style.display = "block";}
                  icon = this.getNodeIcon(node);           // 节点的图标
                  text = this.getNodeIcon2(node);          // 节点的文字型图标
                  if (node_type==1) {                           // 是收拢文件夹
                        fn = node.parameters.getValue("folder");
                        if (fn == "") {fn = this.iconParameters.getValue((isRoot?"root":"folder"));}
                        if (fn == "") {text.innerText = "□ ";}
                        else {icon.src = this.getIcon(fn);}
                  }
                  else {fn = node.parameters.getValue("folderOpen");
                        if (fn == "") {fn = this.iconParameters.getValue((isRoot?"root":"folderOpen"));}
                        if (fn == "") {text.innerText = "■ ";}
                        else {icon.src = this.getIcon(fn);}
                  }
           }
      }

//============= 公共函数 =====================

      tree_obj.setHighLight = function() {        // 设置指定节点的状态，及清除其他节点的高亮状态。
            var args = this.setHighLight.arguments;
            var ps = this.creater.create(               // 节点参数接收器
                   "isHighLight   = true"               // 是否设为高亮（缺省是）。
                 , "isClearOldHighLight = true"         // 是否同时清除原当前节点的高亮（缺省是）。
                 , "isClearAllHighLight = false"        // 是否同时清除所有节点的高亮（缺省否）。
                 , "isCurrent = true"                   // 是否将指定节点设置为当前的（缺省是）。
            );
            ps.appendable = false;       // 仅允许有上述参数。
            var i;
            var node = this.root;
            if (args.length==0 || typeof(args[0])=="string") {
                  for (i=0; i<args.length; i++) {ps.accept(args[i]);}
            }
            else {node = args[0];
                  for (i=1; i<args.length; i++) {ps.accept(args[i]);}
            }
            var isHighLight         = ps.getBoolean("isHighLight",         true);
            var isClearOldHighLight = ps.getBoolean("isClearOldHighLight", true);
            var isClearAllHighLight = ps.getBoolean("isClearAllHighLight", false);
            var isCurrent           = ps.getBoolean("isCurrent",           true);

            if (isClearAllHighLight) {
                  for (var i=0; i<this.nodes.length; i++) {
                        if (!this.nodes[i].isDeleted) {this.clearHighLight(this.nodes[i]);}
                  }
            }
            else {if (isClearOldHighLight && this.currentNode && !this.currentNode.isDeleted) {
                        this.clearHighLight(this.currentNode);
                  }
            }
            if (node.element) {
                  var node_text = this.getNodeText(node);
                  node_text.style.backgroundColor = this.basicParameters.getValue( (isHighLight?"currentBgColor":"generalBgColor") );
                  node_text.style.color           = this.basicParameters.getValue( (isHighLight?"currentColor":"generalColor") );
            }
            node.isHighLight = isHighLight;
            if (isCurrent) {this.currentNode = node;}
      }
      tree_obj.clearHighLight = function(node) {        // 将指定节点清除高亮。
            if (node.element) {
                  var node_text = this.getNodeText(node);
                  node_text.style.backgroundColor = this.basicParameters.getValue("generalBgColor");
                  node_text.style.color           = this.basicParameters.getValue("generalColor");
            }
            node.isHighLight = false;
      }
      tree_obj.resetLeaf = function(node) {        // 将指定节点（缺省：根节点）下的底层节点设为叶子。
            if (node==null) {node = this.root;}
            for (var i=0; i<node.subNodes.length; i++) {
                  if (!node.subNodes[i].isDeleted  && node.subNodes[i].parameters.getInteger("type")!=0) {
                        if (node.subNodes[i].subNodes.length==0) {this.setLeaf(node.subNodes[i]);}
                        else {this.resetLeaf(node.subNodes[i]);}
                  }
            }
      }
      tree_obj.setLeaf = function(node) {        // 将指定节点设为叶子。
            node.parameters.setValue("type", 0);
            if (node.element) {
                  var icon = this.getNodeIcon(node);           // 节点的图标
                  var text = this.getNodeIcon2(node);          // 节点的文字型图标
                  var fn = node.parameters.getValue("leaf");   // 图片文件名
                  if (fn == "") {fn = this.iconParameters.getValue("leaf");}
                  if (fn == "") {
                        icon.style.display = "none";
                        text.style.display = "block";
                        text.innerText = " ";
                  }
                  else {icon.style.display = "block";
                        text.style.display = "none";
                        icon.src = this.getIcon(fn);
                  }
                  this.setConIcon(node);             // 根据是否是最后一个节点，设置连接线、竖线
            }
      }
      tree_obj.updateText = function(node, txt) {   // 修改指定节点的显示文字
            node.parameters.accept("text="+txt);
            var text_obj = this.getNodeText(node);
            text_obj.innerText = txt;
      }
      tree_obj.getNodeCon = function(node) {   // 获取：节点的加减号连接线图标元素
            if (node.element) {return node.element.rows[0].cells[0].children[0];}
            else {return null;}
      }
      tree_obj.getNodeCon2 = function(node) {   // 获取：节点的加减号连接线图标（文字型）元素
            if (node.element) {return node.element.rows[0].cells[1].children[0].rows[0].cells[0];}
            else {return null;}
      }
      tree_obj.getNodeCheckbox = function(node) {   // 获取：节点的检查盒元素
            if (node.element) {return node.element.rows[0].cells[1].children[0].rows[0].cells[2].children[0];}
            else {return null;}
      }
      tree_obj.getNodeIcon = function(node) {   // 获取：节点的图标元素
            if (node.element) {return node.element.rows[0].cells[1].children[0].rows[0].cells[1].children[0];}
            else {return null;}
      }
      tree_obj.getNodeIcon2 = function(node) {   // 获取：节点的图标（文字型）元素
            if (node.element) {return node.element.rows[0].cells[1].children[0].rows[0].cells[1].children[1];}
            else {return null;}
      }
      tree_obj.getNodeText = function(node) {   // 获取：节点的文字元素
            if (node.element) {return node.element.rows[0].cells[1].children[0].rows[0].cells[3];}
            else {return null;}
      }
      tree_obj.resetCheckBox = function(node, b, chooseMode) {  // 设置检查盒。chooseMode：0：仅当前节点；1：包括直接子节点；2：包括所有子节点
            b = (b?true:false);
            if (isNaN(chooseMode)) {chooseMode = 2;}
            node.isChecked = b;
            var node_checkbox = this.getNodeCheckbox(node);
            if (node_checkbox) {node_checkbox.checked = b;}
            if (chooseMode > 0) {
                  if (chooseMode == 1) {chooseMode = 0;}
//                  if (node.parameters.getInteger("type")!=0) {this.expand(node);}     // 如果要重新设置下层节点，则使之展开
                  for (var i=0; i<node.subNodes.length; i++) {this.resetCheckBox(node.subNodes[i], b, chooseMode);}
            }
      }
      tree_obj.resetParentCheckBox = function(node, b, isAll) {    // 设置父节点的检查盒。isAll：是否直到根节点。
            if (node.parentNode) {
                  this.resetCheckBox(node.parentNode, b, 0);
                  if (isAll) {this.resetParentCheckBox(node.parentNode, b, true);}
            }
            else {return;}
      }
      tree_obj.clear = function(node) {                  // 清除指定节点的所有下层节点
            var delete_nodes = this.findSubNodes(node, "includeDeleted=true");
            var new_nodes = new Array();
            for (var i=0; i<this.nodes.length; i++) {
                  var isDeleted = false;
                  for (var j=0; j<delete_nodes.length; j++) {
                        if (this.nodes[i]==delete_nodes[j]) {
                              isDeleted = true;
                              break;
                        }
                  }
                  if (!isDeleted) {
                        new_nodes[new_nodes.length] = this.nodes[i];
                  }
            }
            if (node.element) {
                  var sonsTable = node.element.rows[1].cells[1].children[0];              // 同层节点的集合
                  for (var i=sonsTable.rows.length-1; i>=0; i--) {sonsTable.deleteRow(i);}
            }
            node.subNodes = new Array();
            this.nodes = new_nodes;
            this.currentNode = null;
      }
      tree_obj.deleteNode = function(node) {                  // 删除指定节点
//            if (node.isDeleted) {return;}
            node.isDeleted = true;
            if (node.element && node.parentNode) {
                  var sonsTable = node.parentNode.element.rows[1].cells[1].children[0];              // 同层节点的集合
                  for (var i=0; i<sonsTable.rows.length; i++) {
                        if (sonsTable.rows[i].cells[0].children[0].nodeIndex == node.index) {
// “隐藏行”的方法：
                              sonsTable.rows[i].style.display = "none";
                              for (var k=node.parentNode.subNodes.length-1; k>=0; k--) {  // 将最后一个未删除的节点重置最后节点。
                                    if (!node.parentNode.subNodes[k].isDeleted) {
                                          if (!node.parentNode.subNodes[k].isLast) {
                                                node.parentNode.subNodes[k].isLast = true;
                                                this.setConIcon(node.parentNode.subNodes[k]);
                                          }
                                          break;
                                    }
                              }
/* “直接删除行”的方法：
                              if (this.currentNode) {     // 如果当前节点存在，则检查：当前节点是否已被删除
                                    if (this.currentNode==node) {this.currentNode = null;}
                                    else {var s_nodes = this.findSubNodes(node, "name", this.currentNode.parameters.getValue("name"));
                                          if (s_nodes.length>0) {this.currentNode = null;}
                                    }
                              }
                              sonsTable.deleteRow(i);                // 删除一行
                              if (i==sonsTable.rows.length) {        // 删除的是最后一个节点，则调整最后节点的连线图符
                                    if (i > 0) {                          // 如果还存在最后一个节点
                                          var preNode = this.nodes[sonsTable.rows[i-1].cells[0].children[0].nodeIndex];
                                          preNode.isLast = true;
                                          this.setConIcon(preNode);
                                    }
                              }
                              if (sonsTable.rows.length>0) {      // 为了同层节点的显示完整，做下述步骤。
                                    node0 = this.nodes[sonsTable.rows[0].cells[0].children[0].nodeIndex];
                                    var oldHTML = node0.element.outerHTML;
                                    sonsTable.deleteRow(0);                // 删除一行
                                    sonsTable.insertRow(0);
                                    sonsTable.rows[0].style.verticalAlign = "top";
                                    sonsTable.rows[0].insertCell();                                          // 插入一列
                                    sonsTable.rows[0].cells[0].style.textAlign="left";
                                    sonsTable.rows[0].cells[0].noWrap = true;
                                    sonsTable.rows[0].cells[0].innerHTML = oldHTML;
                                    sonsTable.rows[0].cells[0].children[0].nodeIndex = node0.index;
                                    node0.element = sonsTable.rows[0].cells[0].children[0];
                                    this.nodes[node0.index] = node0;
                                    this.setNode(node0, false);
                              }
*/
                              break;
                        }
                  }
            }
//            node.element = null;
//            node.parentNode = null;
      }
      tree_obj.moveNode = function(node, beforeOfNode) {   // 移动节点到指定节点之前（指定节点不存在或不是同层的，则移到最后）
//            if (node.isDeleted || (node.parentNode && node.parentNode.isDeleted) ) {return;}
            if (node.element && node.parentNode) {                                            // 本层节点已画
                  var sonsTable = node.parentNode.element.rows[1].cells[1].children[0];       // 同层节点的集合
                  for (var i=0; i<sonsTable.rows.length; i++) {
                        if (sonsTable.rows[i].cells[0].children[0].nodeIndex == node.index) {
/* “隐藏行”的方法：
                              var oldHTML = sonsTable.rows[i].cells[0].children[0].outerHTML;
                              sonsTable.rows[i].style.display = "none";
                              var subNodes = new Array();
                              var rowNo = sonsTable.rows.length;
                              if (beforeOfNode==null || node.parentNode!=beforeOfNode.parentNode) {   // 缺省情况
                                    for (var k=0; k<node.parentNode.subNodes.length; k++) {
                                          if (node.parentNode.subNodes[k].index != node.index) {
                                                subNodes[subNodes.length] = node.parentNode.subNodes[k];
                                          }
                                    }
                                    subNodes[subNodes.length] = node;
                              }
                              else {var n;
                                    for (n=0; n<node.parentNode.subNodes.length; n++) {
                                          if (node.parentNode.subNodes[n].index==beforeOfNode.index) {break;}
                                          else {if (node.parentNode.subNodes[n].index != node.index) {
                                                      subNodes[subNodes.length] = node.parentNode.subNodes[n];
                                                }
                                          }
                                    }
                                    for (rowNo=0; rowNo<sonsTable.rows.length; rowNo++) {
                                          if (sonsTable.rows[rowNo].style.display!="none"
                                                     && sonsTable.rows[rowNo].cells[0].children[0].nodeIndex==node.parentNode.subNodes[n].index) {
                                                break;
                                          }
                                    }
                                    subNodes[subNodes.length] = node;
                                    for (var k=n; k<node.parentNode.subNodes.length; k++) {
                                          if (node.parentNode.subNodes[k].index != node.index) {
                                                subNodes[subNodes.length] = node.parentNode.subNodes[k];
                                          }
                                    }
                              }
                              sonsTable.insertRow(rowNo);
                              sonsTable.rows[rowNo].style.verticalAlign = "top";
                              sonsTable.rows[rowNo].insertCell();                                          // 插入一列
                              sonsTable.rows[rowNo].cells[0].style.textAlign="left";
                              sonsTable.rows[rowNo].cells[0].noWrap = true;
                              sonsTable.rows[rowNo].cells[0].innerHTML = oldHTML;
                              sonsTable.rows[rowNo].cells[0].children[0].nodeIndex = node.index;
                              node.element = sonsTable.rows[rowNo].cells[0].children[0];
                              node.parentNode.subNodes = subNodes;
                              this.nodes[node.index] = node;
                              var k;
                              for (k=node.parentNode.subNodes.length-1; k>=0; k--) {  // 将最后一个未删除的节点重置最后节点。
                                    if (!node.parentNode.subNodes[k].isDeleted) {
                                          if (!node.parentNode.subNodes[k].isLast) {
                                                node.parentNode.subNodes[k].isLast = true;
                                                this.setConIcon(node.parentNode.subNodes[k]);
                                          }
                                          break;
                                    }
                              }
                              for (var j=k-1; j>=0; j--) {    // 将之前的最后节点置为非最后节点。
                                    if (!node.parentNode.subNodes[j].isDeleted) {
                                          if (node.parentNode.subNodes[j].isLast) {
                                                node.parentNode.subNodes[j].isLast = false;
                                                this.setConIcon(node.parentNode.subNodes[j]);
                                          }
                                    }
                              }
*/
// “直接删除行”的方法：
                              var oldHTML = sonsTable.rows[i].cells[0].children[0].outerHTML;
                              sonsTable.deleteRow(i);                // 删除一行
                              var subNodes = new Array();
                              var rowNo = sonsTable.rows.length;
                              if (beforeOfNode==null || node.parentNode!=beforeOfNode.parentNode) {   // 缺省情况
                                    for (var k=0; k<node.parentNode.subNodes.length; k++) {
                                          if (node.parentNode.subNodes[k].index != node.index) {
                                                subNodes[subNodes.length] = node.parentNode.subNodes[k];
                                          }
                                    }
                                    subNodes[subNodes.length] = node;
                              }
                              else {var n;
                                    for (n=0; n<node.parentNode.subNodes.length; n++) {
                                          if (node.parentNode.subNodes[n].index==beforeOfNode.index) {break;}
                                          else {if (node.parentNode.subNodes[n].index != node.index) {
                                                      subNodes[subNodes.length] = node.parentNode.subNodes[n];
                                                }
                                          }
                                    }
                                    for (rowNo=0; rowNo<sonsTable.rows.length; rowNo++) {
                                          if (sonsTable.rows[rowNo].cells[0].children[0].nodeIndex == node.parentNode.subNodes[n].index) {break;}
                                    }
                                    subNodes[subNodes.length] = node;
                                    for (var k=n; k<node.parentNode.subNodes.length; k++) {
                                          if (node.parentNode.subNodes[k].index != node.index) {
                                                subNodes[subNodes.length] = node.parentNode.subNodes[k];
                                          }
                                    }
                              }
                              sonsTable.insertRow(rowNo);
                              sonsTable.rows[rowNo].style.verticalAlign = "top";
                              sonsTable.rows[rowNo].insertCell();                                          // 插入一列
                              sonsTable.rows[rowNo].cells[0].style.textAlign="left";
                              sonsTable.rows[rowNo].cells[0].noWrap = true;
                              sonsTable.rows[rowNo].cells[0].innerHTML = oldHTML;
                              sonsTable.rows[rowNo].cells[0].children[0].nodeIndex = node.index;
                              node.element = sonsTable.rows[rowNo].cells[0].children[0];
                              node.parentNode.subNodes = subNodes;
                              this.nodes[node.index] = node;
                              var node_obj;
                              for (var k=0; k<sonsTable.rows.length-1; k++) {
                                    node_obj = this.nodes[sonsTable.rows[k].cells[0].children[0].nodeIndex];
                                    if (node_obj.isLast) {
                                          node_obj.isLast = false;
                                          this.setConIcon(node_obj);
                                    }
                              }
                              node_obj = this.nodes[sonsTable.rows[sonsTable.rows.length-1].cells[0].children[0].nodeIndex];
                              if (!node_obj.isLast) {
                                    node_obj.isLast = true;
                                    this.setConIcon(node_obj);
                              }
//
                              this.setNode(node, false);
                              break;
                        }
                  }
            }
            else {                   // 未画节点的位置调整。
                  var subNodes = new Array();
                  if (beforeOfNode==null || node.parentNode!=beforeOfNode.parentNode) {   // 缺省情况
                        for (var k=0; k<node.parentNode.subNodes.length; k++) {
                              if (node.parentNode.subNodes[k].index != node.index) {
                                    subNodes[subNodes.length] = node.parentNode.subNodes[k];
                              }
                        }
                        subNodes[subNodes.length] = node;
                  }
                  else {var n;
                        for (n=0; n<node.parentNode.subNodes.length; n++) {
                              if (node.parentNode.subNodes[n].index==beforeOfNode.index) {break;}
                              else {if (node.parentNode.subNodes[n].index != node.index) {
                                          subNodes[subNodes.length] = node.parentNode.subNodes[n];
                                    }
                              }
                        }
                        subNodes[subNodes.length] = node;
                        for (var k=n; k<node.parentNode.subNodes.length; k++) {
                              if (node.parentNode.subNodes[k].index != node.index) {
                                    subNodes[subNodes.length] = node.parentNode.subNodes[k];
                              }
                        }
                  }
                  for (var k=0; k<subNodes.length-1; k++) {subNodes[k].isLast = false;}
                  subNodes[subNodes.length-1].isLast = true;
                  node.parentNode.subNodes = subNodes;
                  this.nodes[node.index] = node;
            }
      }
      tree_obj.expand = function(node) {   // 展开
//alert("expand : isExpand="+node.isExpand+", node.subNodes.length="+node.subNodes.length);
            if (node.parentNode && !node.parentNode.isExpand) {
                  tree_obj.expand(node.parentNode);
            }
            if (!node.isExpand) {
                  node.isExpand = true;
                  for (var i=0; i<node.subNodes.length; i++) {this.drawNode(node.subNodes[i]);}
            }
//alert("type="+node.parameters.getValue("type"));
            node.parameters.setValue("type", 2);
            var fn;
            var icon = this.getNodeCon(node);           // 节点的加减号连接线图标
            var text = this.getNodeCon2(node);          // 节点的加减号连接线文字
            text.innerText = "━";
            fn = this.iconParameters.getValue("└ -");
            if (node.isLast && fn!="") {icon.src = this.getIcon(fn);}
            fn = this.iconParameters.getValue("├ -");
            if (!node.isLast && fn!="") {icon.src = this.getIcon(fn);}
            icon = this.getNodeIcon(node);           // 节点的图标
            text = this.getNodeIcon2(node);          // 节点的文字型图标
            fn = node.parameters.getValue("folderOpen");
            if (fn == "") {fn = this.iconParameters.getValue("folderOpen");}
            if (fn == "") {text.innerText = "■ ";}
            else {icon.src = this.getIcon(fn);}
            if (node.subNodes.length>0) {node.element.rows[1].style.display = "block";}        // 如果有子节点
            else {this.eventProcess("getSon", node.index);}
            this.eventProcess("expand", node.index);
      }
      tree_obj.collapse = function(node) {   // 收拢
            node.parameters.setValue("type", 1);
            node.element.rows[1].style.display = "none";
            var fn;
            var icon = this.getNodeCon(node);           // 节点的加减号连接线图标
            var text = this.getNodeCon2(node);          // 节点的加减号连接线文字
            text.innerText = "╋";
            fn = this.iconParameters.getValue("└ +");
            if (node.isLast && fn!="") {icon.src = this.getIcon(fn);}
            fn = this.iconParameters.getValue("├ +");
            if (!node.isLast && fn!="") {icon.src = this.getIcon(fn);}
            icon = this.getNodeIcon(node);           // 节点的图标
            text = this.getNodeIcon2(node);          // 节点的文字型图标
            fn = node.parameters.getValue("folder");
            if (fn == "") {fn = this.iconParameters.getValue("folder");}
            if (fn == "") {text.innerText = "□ ";}
            else {icon.src = this.getIcon(fn);}
            this.eventProcess("collapse", node.index);
      }
      tree_obj.create = function(put_obj) {                      // 创建树的根
            if (!put_obj) {alert("目标元素不存在"); return;}
            if (this.root.element != null) {alert("根节点已经建立"); return;}

            this.root.element = document.createElement('table');                     // 树的根 TABLE
            put_obj.appendChild(this.root.element);
            this.root.element.nodeIndex = "";              // nodes 数组中的下标
            this.root.element.cellPadding = 0;
            this.root.element.cellSpacing = 0;
            this.root.element.border = 0;
            this.root.element.style.backgroundColor = this.basicParameters.getValue("generalBgColor");
            this.root.element.insertRow(0);                          // 第1行放根节点图标和文字
            this.root.element.rows[0].style.verticalAlign = "top";
            this.root.element.rows[0].insertCell();                     // 第1列空置
            this.root.element.rows[0].insertCell();                     // 第2列放图标和文字
            this.root.element.rows[0].style.display = (this.root.parameters.getBoolean("isHidden")?"none":"block");
            this.root.element.insertRow(1);                          // 第2行放子节点
            this.root.element.rows[1].style.verticalAlign = "top";
            this.root.element.rows[1].insertCell();                     // 第1列空置。对于其他节点，放竖线
            this.root.element.rows[1].insertCell();                     // 第2列放子节点
//-------- 第1行第1列 ----------------
            this.root.con_icon = document.createElement('img');            // 节点的加减号连接线图标
            this.root.element.rows[0].cells[0].appendChild(this.root.con_icon);
//-------- 第1行第2列 ----------------
            var showTable = document.createElement('table');                     // 节点的显示 TABLE
            this.root.element.rows[0].cells[1].appendChild(showTable);
            showTable.cellPadding = 0;
            showTable.cellSpacing = 0;
            showTable.border = 0;
            showTable.style.backgroundColor = this.basicParameters.getValue("generalBgColor");
            showTable.insertRow(0);
            showTable.rows[0].style.verticalAlign = "middle";
            showTable.rows[0].insertCell();                                              // 放节点的加减号连接线文字
            showTable.rows[0].insertCell();                                              // 放节点的图标（包括：文字型图标）
            showTable.rows[0].insertCell();                                              // 放节点的检查盒
            showTable.rows[0].insertCell();                                              // 放节点的文字
            showTable.rows[0].cells[1].appendChild(document.createElement('img'));         // 节点的图标
            showTable.rows[0].cells[1].appendChild(document.createElement('span'));        // 节点的文字型图标
            showTable.rows[0].cells[2].innerHTML = "<input type='checkbox'>";              // 节点的检查盒
            showTable.rows[0].cells[3].noWrap = true;
            showTable.rows[0].cells[3].style.textIndent = this.basicParameters.getInteger("textIndent");
            showTable.rows[0].cells[3].style.backgroundColor = this.basicParameters.getValue("generalBgColor");
            showTable.rows[0].cells[3].style.color           = this.basicParameters.getValue("generalColor");
            showTable.rows[0].cells[3].innerHTML = this.root.parameters.getValue("text");
            showTable.rows[0].cells[3].title     = this.root.parameters.getValue("tip");
//-------- 第2行第1列 ----------------

//-------- 第2行第2列 ----------------
            this.root.element.rows[1].cells[1].appendChild(document.createElement('table'));         // 子节点的集合
            this.root.element.rows[1].cells[1].children[0].cellPadding = 0;
            this.root.element.rows[1].cells[1].children[0].cellSpacing = 0;
            this.root.element.rows[1].cells[1].children[0].border = 0;

            this.root.isChecked = this.root.parameters.getBoolean("isChecked", false);
            this.root.isRoot    = true;             // 本节点是否是根节点
            this.setNode(this.root, true);
            this.root.isExpand    = true;           // 根节点总是展开
            for (var i=0; i<this.root.subNodes.length; i++) {this.drawNode(this.root.subNodes[i]);}
      }
      tree_obj.getNode = function(n) {               // 取第n个节点。n 从 0 计数。找不到则返回根节点。
            if (isNaN(n) || n<0 || n>=this.nodes.length) {return this.root;}
            else {return this.nodes[n];}
      }
      tree_obj.findSubNodes = function() {   // 获得：node节点（缺省：根）下“name=value”的子节点，并保存到nodeArray（缺省：新建）中。
            var args = this.findSubNodes.arguments;
            var ps = this.creater.create(      // 节点参数接收器
                   "includeDeleted = false"            // 是否包括已删除的节点
                 , "isFaint        = false"            // 是否模糊匹配
                 , "isAllLevel     = true"             // 是否所有子层，否则仅紧下层（缺省是）。
                 , "ignoreCheckbox = true"             // 是否忽略检查盒状态（缺省是）。
                 , "isChecked      = true"             // 如果不忽略检查盒状态，则是否是取选中的（缺省是）。
                 , "ignoreType     = true"             // 是否忽略叶子状态（缺省是）。
                 , "isLeaf         = true"             // 如果不忽略叶子状态，则是否是取叶子（缺省是）。
            );
            ps.appendable = true;       // 除上述参数外，还允许有匹配条件。
            var psNames = ps.getParameterNames();       // 当前定义的参数名。
            var i;
            var node = this.root;
            var nodeArray = new Array();
            if (args.length==0 || typeof(args[0])=="string") {
                  for (i=0; i<args.length; i++) {ps.accept(args[i]);}
            }
            else {node = args[0];
                  if (args.length==1 || typeof(args[1])=="string") {
                        for (i=1; i<args.length; i++) {ps.accept(args[i]);}
                  }
                  else {nodeArray = args[1];
                        for (i=2; i<args.length; i++) {ps.accept(args[i]);}
                  }
            }
            if (node.subNodes.length==0) {return nodeArray;}
            var includeDeleted = ps.getBoolean("includeDeleted", false);
            var isFaint        = ps.getBoolean("isFaint",        false);
            var isAllLevel     = ps.getBoolean("isAllLevel",     true);
            var ignoreCheckbox = ps.getBoolean("ignoreCheckbox", true);
            var isChecked      = ps.getBoolean("isChecked",      true);
            var ignoreType     = ps.getBoolean("ignoreType",     true);
            var isLeaf         = ps.getBoolean("isLeaf",         true);
            var j, isFind;
            var conditions = new Array();
            for (i=0; i<ps.attributes.length; i++) {
                  isFind = false;
                  for (j=0; j<psNames.length; j++) {
                        if (ps.attributes[i].name==psNames[j]) {
                              isFind = true;
                              break;
                        }
                  }
                  if (!isFind) {
                        conditions[conditions.length] = ps.attributes[i];
                  }
            }
//--------- 以上是分析参数，下面开始寻找 ------------------------------
            if (isFaint) {
                  for (i=0; i<node.subNodes.length; i++) {
                        if (includeDeleted || !node.subNodes[i].isDeleted) {
                              if ( (ignoreCheckbox || node.subNodes[i].isChecked==isChecked)
                                                      && (ignoreType || (node.subNodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                                    isFind = true;
                                    for (j=0; j<conditions.length; j++) {
                                          if (node.subNodes[i].parameters.getValue(conditions[j].name).indexOf(conditions[j].value)<0) {
                                                isFind = false;
                                                break;
                                          }
                                    }
                                    if (isFind) {nodeArray[nodeArray.length] = node.subNodes[i];}
                              }
                              if (isAllLevel) {this.findSubNodes_recursion_isFaint(node.subNodes[i], nodeArray, includeDeleted, ignoreCheckbox, isChecked, ignoreType, isLeaf, conditions);}
                        }
                  }
            }
            else {for (i=0; i<node.subNodes.length; i++) {
                        if (includeDeleted || !node.subNodes[i].isDeleted) {
                              if ( (ignoreCheckbox || node.subNodes[i].isChecked==isChecked)
                                                      && (ignoreType || (node.subNodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                                    isFind = true;
                                    for (j=0; j<conditions.length; j++) {
                                          if (node.subNodes[i].parameters.getValue(conditions[j].name)!=conditions[j].value) {
                                                isFind = false;
                                                break;
                                          }
                                    }
                                    if (isFind) {nodeArray[nodeArray.length] = node.subNodes[i];}
                              }
                              if (isAllLevel) {this.findSubNodes_recursion(node.subNodes[i], nodeArray, includeDeleted, ignoreCheckbox, isChecked, ignoreType, isLeaf, conditions);}
                        }
                  }
            }
            return nodeArray;
      }
//------------ 以下是2个内部使用的递归函数 -----------------------------------
      tree_obj.isChecked = function(node) {   // 指定节点的检查盒是否被选中
            if (node.parameters.getInteger("checkbox")==0) {return node.isChecked;}
            else {var chk_obj = this.getNodeCheckbox(node);
                  if (chk_obj) {return chk_obj.checked;}
                  else {return node.isChecked;}
            }
      }
      tree_obj.findSubNodes_recursion_isFaint = function(node, nodeArray, includeDeleted, ignoreCheckbox, isChecked, ignoreType, isLeaf, conditions) {
            var i, j, isFind;
            for (i=0; i<node.subNodes.length; i++) {
                  if (includeDeleted || !node.subNodes[i].isDeleted) {
                        if ( (ignoreCheckbox || node.subNodes[i].isChecked==isChecked)
                                                      && (ignoreType || (node.subNodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                              isFind = true;
                              for (j=0; j<conditions.length; j++) {
                                    if (node.subNodes[i].parameters.getValue(conditions[j].name).indexOf(conditions[j].value)<0) {
                                          isFind = false;
                                          break;
                                    }
                              }
                              if (isFind) {nodeArray[nodeArray.length] = node.subNodes[i];}
                        }
                        this.findSubNodes_recursion_isFaint(node.subNodes[i], nodeArray, includeDeleted, ignoreCheckbox, isChecked, ignoreType, isLeaf, conditions);
                  }
            }
      }
      tree_obj.findSubNodes_recursion = function(node, nodeArray, includeDeleted, ignoreCheckbox, isChecked, ignoreType, isLeaf, conditions) {
            var isFind;
            for (var i=0; i<node.subNodes.length; i++) {
                  if (includeDeleted || !node.subNodes[i].isDeleted) {
                        if ( (ignoreCheckbox || node.subNodes[i].isChecked==isChecked)
                                                      && (ignoreType || (node.subNodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                              isFind = true;
                              for (var j=0; j<conditions.length; j++) {
                                    if (node.subNodes[i].parameters.getValue(conditions[j].name)!=conditions[j].value) {
                                          isFind = false;
                                          break;
                                    }
                              }
                              if (isFind) {nodeArray[nodeArray.length] = node.subNodes[i];}
                        }
                        this.findSubNodes_recursion(node.subNodes[i], nodeArray, includeDeleted, ignoreCheckbox, isChecked, ignoreType, isLeaf, conditions);
                  }
            }
      }
//-----------------------------------------------
      tree_obj.findNode = function() {  // 寻找第一个满足条件的节点。条件格式只能是“name=value”。各条件的关系是“与”。
            if (this.nodes.length==0) {return null;}
            var args = this.findNode.arguments;
            var ps = this.creater.create(      // 节点参数接收器
                   "point          = 0"                // 从point-1开始往前找
                 , "isFaint        = false"            // 是否模糊匹配
                 , "includeDeleted = false"            // 是否包括已删除的节点
                 , "ignoreCheckbox = true"             // 是否忽略检查盒状态（缺省是）。
                 , "isChecked      = true"             // 如果不忽略检查盒状态，则是否是取选中的（缺省是）。
                 , "ignoreType     = true"             // 是否忽略叶子状态（缺省是）。
                 , "isLeaf         = true"             // 如果不忽略叶子状态，则是否是取叶子（缺省是）。
            );
            ps.appendable = true;       // 除上述参数外，还允许有匹配条件。
            var psNames = ps.getParameterNames();       // 当前定义的参数名。
            var i;
            for (i=0; i<args.length; i++) {ps.accept(args[i]);}
            var n              = ps.getInteger("point",          0);
            var isFaint        = ps.getBoolean("isFaint",        false);
            var includeDeleted = ps.getBoolean("includeDeleted", false);
            var ignoreCheckbox = ps.getBoolean("ignoreCheckbox", true);
            var isChecked      = ps.getBoolean("isChecked",      true);
            var ignoreType     = ps.getBoolean("ignoreType",     true);
            var isLeaf         = ps.getBoolean("isLeaf",         true);
            var j, isFind;
            var conditions = new Array();
            for (i=0; i<ps.attributes.length; i++) {
                  isFind = false;
                  for (j=0; j<psNames.length; j++) {
                        if (ps.attributes[i].name==psNames[j]) {
                              isFind = true;
                              break;
                        }
                  }
                  if (!isFind) {
                        conditions[conditions.length] = ps.attributes[i];
                  }
            }
            if (n<0) {n = 0;}
            i = n-1;
            if (isFaint) {   // 是模糊匹配
                  while (true) {
                        i = (i<0?this.nodes.length-1:i);
                        if (includeDeleted || !this.nodes[i].isDeleted) {
                              if ( (ignoreCheckbox || this.nodes[i].isChecked==isChecked)
                                                 && (ignoreType || (this.nodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                                    isFind = true;
                                    for (j=0; j<conditions.length; j++) {
                                          if (this.nodes[i].parameters.getValue(conditions[j].name).indexOf(conditions[j].value)<0) {
                                                isFind = false;
                                                break;
                                          }
                                    }
                                    if (isFind) {return this.nodes[i];}
                              }
                        }
                        if (i==n) {break;}
                        else {i--;}
                  }
            }
            else {while (true) {
                        i = (i<0?this.nodes.length-1:i);
                        if (includeDeleted || !this.nodes[i].isDeleted) {
                              if ( (ignoreCheckbox || this.nodes[i].isChecked==isChecked)
                                                 && (ignoreType || (this.nodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                                    isFind = true;
                                    for (j=0; j<conditions.length; j++) {
                                          if (this.nodes[i].parameters.getValue(conditions[j].name)!=conditions[j].value) {
                                                isFind = false;
                                                break;
                                          }
                                    }
                                    if (isFind) {return this.nodes[i];}
                              }
                        }
                        if (i==n) {break;}
                        else {i--;}
                  }
            }
            return null;
      }
      tree_obj.findNodes = function() {  // 寻找所有满足条件的节点。条件格式只能是“name=value”。各条件的关系是“与”。
            var ns = new Array();
            if (this.nodes.length==0) {return ns;}
            var args = this.findNodes.arguments;
            var ps = this.creater.create(      // 节点参数接收器
                   "point          = 0"                // 从point-1开始往前找
                 , "isFaint        = false"            // 是否模糊匹配
                 , "includeDeleted = false"            // 是否包括已删除的节点
                 , "ignoreCheckbox = true"             // 是否忽略检查盒状态（缺省是）。
                 , "isChecked      = true"             // 如果不忽略检查盒状态，则是否是取选中的（缺省是）。
                 , "ignoreType     = true"             // 是否忽略叶子状态（缺省是）。
                 , "isLeaf         = true"             // 如果不忽略叶子状态，则是否是取叶子（缺省是）。
            );
            ps.appendable = true;       // 除上述参数外，还允许有匹配条件。
            var psNames = ps.getParameterNames();       // 当前定义的参数名。
            var i;
            for (i=0; i<args.length; i++) {ps.accept(args[i]);}
            var n              = ps.getInteger("point",          0);
            var isFaint        = ps.getBoolean("isFaint",        false);
            var includeDeleted = ps.getBoolean("includeDeleted", false);
            var ignoreCheckbox = ps.getBoolean("ignoreCheckbox", true);
            var isChecked      = ps.getBoolean("isChecked",      true);
            var ignoreType     = ps.getBoolean("ignoreType",     true);
            var isLeaf         = ps.getBoolean("isLeaf",         true);
            var j, isFind;
            var conditions = new Array();
            for (i=0; i<ps.attributes.length; i++) {
                  isFind = false;
                  for (j=0; j<psNames.length; j++) {
                        if (ps.attributes[i].name==psNames[j]) {
                              isFind = true;
                              break;
                        }
                  }
                  if (!isFind) {
                        conditions[conditions.length] = ps.attributes[i];
                  }
            }
            if (n<0) {n = 0;}
//alert("findNodes：includeDeleted="+includeDeleted+", isFaint="+isFaint+", ignoreCheckbox="+ignoreCheckbox+", isChecked="+isChecked+", ignoreType="+ignoreType+", isLeaf="+isLeaf);
            i = n-1;
            if (isFaint) {   // 是模糊匹配
                  while (true) {
                        i = (i<0?this.nodes.length-1:i);
                        if (includeDeleted || !this.nodes[i].isDeleted) {
                              if ( (ignoreCheckbox || this.nodes[i].isChecked==isChecked)
                                                 && (ignoreType || (this.nodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                                    isFind = true;
                                    for (j=0; j<conditions.length; j++) {
                                          if (this.nodes[i].parameters.getValue(conditions[j].name).indexOf(conditions[j].value)<0) {
                                                isFind = false;
                                                break;
                                          }
                                    }
                                    if (isFind) {ns[ns.length] = this.nodes[i];}
                              }
                        }
                        if (i==n) {break;}
                        else {i--;}
                  }
            }
            else {while (true) {
//alert("匹配第"+i+"个节点");
                        i = (i<0?this.nodes.length-1:i);
                        if (includeDeleted || !this.nodes[i].isDeleted) {
                              if ( (ignoreCheckbox || this.nodes[i].isChecked==isChecked)
                                                 && (ignoreType || (this.nodes[i].parameters.getInteger("type")==0?true:false)==isLeaf) ) {
                                    isFind = true;
                                    for (j=0; j<conditions.length; j++) {
                                          if (this.nodes[i].parameters.getValue(conditions[j].name)!=conditions[j].value) {
                                                isFind = false;
                                                break;
                                          }
                                    }
                                    if (isFind) {ns[ns.length] = this.nodes[i];}
                              }
                        }
                        if (i==n) {break;}
                        else {i--;}
//alert("找到的节点个数="+ns.length+", 后续i="+i);
                  }
            }
            return ns;
      }
      tree_obj.addNode = function() {    // 加节点。返回：新加节点
            var args = this.addNode.arguments;
            var ps = this.creater.create(      // 节点参数接收器
                   "name       = "             // 节点名
                 , "text       =  "            // 节点的显示文字
                 , "leaf       = "             // 叶子图标
                 , "folder     = "             // 文件夹（闭合）图标
                 , "folderOpen = "             // 展开文件夹的图标
                 , "type       = 1 "           // 节点类型（0——叶子；1——收拢文件夹；2——展开文件夹。）
                 , "checkbox   = 1 "           // 节点检查盒的状态（0——没有；1——有，可用；2——有，不可用。）
                 , "isChecked  = false"        // 节点检查盒是否被选中。缺省不选中。
                 , "tip        = "             // 鼠标置上时显示的标签文字
                 , "parent     = "             // 父节点名
                 , "parentNo   = "             // 父节点在 nodes 数组中的序号
                 , "isExpand   = false"        // 子节点是否先建立（画）。如果节点类型为展开文件夹，则总是建立；否则，缺省不建立。
            );
            for (var i=0; i<args.length; i++) {ps.accept(args[i]);}
            if (ps.getValue("name")=="") {alert("节点名不得为空"); return null;}
            if (this.basicParameters.getBoolean("checkRepeat")) {
                  if (this.findNode("name="+ps.getValue("name"))) {
                        alert("同名节点已存在");
                        return null;
                  }
            }
            var parentNode = null;                 // 父节点
            var parentNo = ps.getInteger("parentNo", -1);
            if (parentNo<0 || parentNo>=this.nodes.length) {
                  var parentName = ps.getValue("parent");
                  if (parentName != "") {parentNode = this.findNode("name="+parentName);}            // 找父节点
            }
            else {parentNode = this.nodes[parentNo];}
            if (!parentNode) {parentNode = this.root;}
            if (parentNode.parameters.getInteger("type")==0) {alert("父节点不是文件夹"); return null;}

            var node = new Object();
            node.element     = null;                                 // HTML 元素
            node.parentNode  = parentNode;                           // 父节点
            node.isRoot      = (parentNode==null?true:false);        // 本节点是否是根节点
            node.parameters  = ps;                                   // 节点参数接收器
            node.isExpand    = ps.getBoolean("isExpand", false);     // 本节点是否已展开
            node.isLast      = true;                                 // 节点是否是本层的最后一个节点
            node.isHighLight = false;                                // 当前是否高亮
            node.isDeleted   = false;                                // 节点是否已被删除
            node.isChecked   = ps.getBoolean("isChecked", false);    // 节点检查盒是否被选中
            node.index       = this.nodes.length;                    // 节点在数组中的位置
            node.subNodes    = new Array();                          // 节点的子节点数组

            this.nodes[this.nodes.length] = node;
            parentNode.subNodes[parentNode.subNodes.length] = node;
            if (parentNode.isExpand) {this.drawNode(node);}
            return node;
      }

      eval(tree_obj.name + " = tree_obj");
      return tree_obj;
}

// Ending Hidden -->