gs-bim-air 3.0.3 → 3.0.5

package/src/viewerWrapper/panels/structureTree/panes/structureTree.ts

@@ -1,1124 +0,0 @@
-import { Component, Inject, Prop, Vue } from "vue-property-decorator";
-import * as Longan from "gs-longan";
-import * as LonganApi from "gs-bim-air-core/gsDevFx/api";
-import GsDivider from "../../../../components/gs/gsDivider/gs-divider.vue";
-
-import Tree from "../../../../components/el/tree";
-import { Button, Input, Form, FormItem, Message, MessageBox } from "element-ui";
-import { ButtonConfig, createMenu } from "../../../module/createMenu";
-import structureTree from "../../../../store/structureTree";
-import { ComponentSelector } from "gs-bim-air-core/gsDevFx/operators/componentSelector";
-import { TreeNodeObject } from "gs-bim-air-core/gsDevFx/objects/treeNodeObject";
-import { Viewer } from "gs-bim-air-core/gsDevFx/viewer";
-import structureTreeBus from "../structureTreeBus";
-import { ViewerEvent } from "gs-longan";
-import PropertyPanel from "../../property/propertyPanel";
-
-Vue.use(Tree);
-Vue.use(Button);
-Vue.use(Input);
-Vue.use(Form);
-Vue.use(FormItem);
-
-@Component({
-  components: { GsDivider },
-})
-export default class StructureTree extends Vue {
-  @Prop() componentData;
-  @Inject() getViewer;
-  searchValue = "";
-  treeProps = {
-    label: "name",
-    children: "childNodes",
-    isLeaf: "isLeaf",
-    expaned: "expaned",
-  };
-  treeCheckedNos = [];
-  treeExpandAll = true;
-  draggingNode = null;
-
-  treeModelStructure = null;
-
-  selectedKey = -1;
-  selectedPath = "";
-  // 勾选的keys
-  checkKeys = [];
-  // 隐藏的keys
-  invisibleKeys = [];
-  // 展开的keys
-  expandedKeys = [];
-  currentTreeKey = null;
-  isEditingKey: string = null;
-  nameValue = "";
-  // modelObjects: TreeNodeObject[] = [];
-  modelObjectsClone = [];
-
-  parentSegmentKey: number = null;
-  treeNodeHoverKey = null;
-  isTreeEditing = false;
-  operatorList = [];
-  contextMenu;
-  currentTreeNodeData: TreeNodeObject;
-  currentTreeNode;
-
-  // 隔离id列表
-  isolationIds = [];
-  levelOneData = [];
-
-  loopFlag = false;
-  selectedGslNode = null;
-  nodePath = [];
-  chooseNode = null;
-  rootNode = null;
-  lastNoCheckedRootNodes = [];
-
-  count = 0;
-  end = false;
-  isolationKeys = [];
-
-  isTreeLocate = localStorage.getItem("isTreeLocate") !== "false";
-
-  level0Node;
-  level0NodeResolve;
-
-  currentNode;
-  currentNodeResolve;
-
-  checkStrictly = false;
-  draggingNodeChecked = true;
-  // isLoading = false;
-  isTreeLoading = false;
-  isChecking = false;
-
-  buttonList: ButtonConfig[] = [
-    {
-      name: "编辑",
-      children: [
-        {
-          name: "添加",
-          clickFun: () => {
-            this.addTreeNodeClick();
-          },
-        },
-        {
-          name: "重命名",
-          clickFun: () => {
-            this.renameTreeNodeClick();
-          },
-        },
-        {
-          name: "删除",
-          clickFun: () => {
-            this.deleteTreeNodeClick();
-          },
-        },
-      ],
-    },
-    // {
-    //   name: "高亮选中对象",
-    //   key: "highlight",
-    //   clickFun: () => {
-    //     //this.componentSelectAndHeighlight();
-    //   },
-    // },
-    {
-      name: "隐藏",
-      children: [
-        {
-          name: "隐藏选中对象",
-          clickFun: () => {
-            this.hideObject();
-          },
-        },
-        {
-          name: "隐藏其他对象",
-          clickFun: () => {
-            this.reHideObject();
-          },
-        },
-        {
-          name: "显示全部对象",
-          clickFun: () => {
-            this.clearHideObject();
-          },
-        },
-      ],
-    },
-    {
-      name: "隔离",
-      children: [
-        {
-          name: "隔离选中对象",
-          clickFun: () => {
-            this.isolateObject();
-          },
-        },
-        {
-          name: "隔离其他对象",
-          clickFun: () => {
-            this.isolateOtherObjects();
-          },
-        },
-        {
-          name: "取消隔离",
-          clickFun: () => {
-            this.clearIsolateObjects();
-          },
-        },
-      ],
-    },
-    {
-      name: "展开",
-      children: [
-        {
-          name: "展开一层",
-          clickFun: () => {
-            this.showLevel(1);
-          },
-        },
-        {
-          name: "展开二层",
-          clickFun: () => {
-            this.showLevel(2);
-          },
-        },
-        {
-          name: "展开三层",
-          clickFun: () => {
-            this.showLevel(3);
-          },
-        },
-        // {
-        //   name: "全部展开", key: "showAll", clickFun: () => {
-        //     this.setAllExpand(true)
-        //   }
-        // },
-        {
-          name: "全部收起",
-          clickFun: () => {
-            this.setAllExpand(false);
-          },
-        },
-      ],
-    },
-  ];
-
-  structureTree = structureTree;
-  treeNodeDragEnterTimer;
-
-  heighLightObserver: Longan.Observer<ViewerEvent>;
-
-  get viewer(): Viewer {
-    return this.getViewer();
-  }
-
-  get tabs() {
-    let tabs = this.viewer.options.components.property.tabs;
-    return tabs;
-  }
-
-  get viewerType() {
-    return this.viewer.options.viewerType;
-  }
-
-  loadNode(node, resolve) {
-    if (!this.viewer) {
-      resolve([]);
-    }
-    this.checkStrictly = true;
-    if (this.viewer?.structureTreeManager?.treeNodeObjects) {
-      this.$nextTick(() => {
-        this.currentNode = node;
-        this.currentTreeNodeData = node.data;
-        this.currentNodeResolve = resolve;
-        if (node.level === 0) {
-          let result;
-          this.level0Node = node; //这里是关键！在data里面定义一个变量，将node.level == 0的node存起来
-          this.level0NodeResolve = resolve; //同
-          // if (
-          //   this.viewer.renderObject
-          // ) {
-          //   result = this.getNodes([this.viewer.structureTreeManager.rootNode]);
-          //   if (this.invisibleKeys.indexOf(result[0].id) === -1) {
-          //     this.checkKeys.push(result[0].id);
-          //   }
-          // } else {
-          //   result = this.getNodes(
-          //     this.viewer.structureTreeManager.rootNode.childNodes
-          //   );
-          //   result.forEach((item) => {
-          //     if (this.invisibleKeys.indexOf(item.id) === -1) {
-          //       this.checkKeys.push(item.id);
-          //     }
-          //   });
-          // }
-
-          result = this.getNodes(this.viewer.structureTreeManager.treeNodeObjects);
-          let childNodes = this.viewer.structureTreeManager.treeNodeObjects;
-          result.forEach((item, index) => {
-            if (childNodes[index].isVisible) {
-              this.checkKeys.push(item.id);
-            }
-          });
-
-          resolve(result);
-        } else {
-          let treeNode = this.viewer.structureTreeManager?.treeNodeObjectHash[node.data.id];
-          if (treeNode) {
-            let childNodes = treeNode.childNodes;
-            // 过滤main节点
-            // if (childNodes.length === 1 && childNodes[0].name === "main") {
-            //   childNodes = childNodes[0].childNodes;
-            // }
-            let result = this.getNodes(childNodes);
-            result.forEach((item, index) => {
-              if (childNodes[index].isVisible) {
-                this.checkKeys.push(item.id);
-              }
-            });
-            return resolve(result);
-          } else {
-            return resolve([]);
-          }
-        }
-      });
-
-      setTimeout(() => {
-        this.checkStrictly = false;
-        // console.log("树结构父子节点重新关联");
-      }, 20);
-    }
-  }
-
-  getNodes(treeNodeObjects: TreeNodeObject[]): {
-    name: string;
-    id: string;
-    isShow: boolean;
-    isLeaf: boolean;
-    expaned: boolean;
-  }[] {
-    let result = [];
-    treeNodeObjects.forEach((item) => {
-      result.push({
-        name: item.name,
-        id: item.id,
-        isShow: item.isShow,
-        isLeaf: item.childNodes.length === 0,
-        expaned: this.expandedKeys.indexOf(item.id) !== -1,
-      });
-    });
-    return result;
-  }
-
-  isTreeLocateChange(val) {
-    localStorage.setItem("isTreeLocate", val);
-    this.isTreeLocate = val;
-  }
-
-  locateCurrentNode(id) {
-    if (!this.isTreeLocate) {
-      return;
-    }
-    this.count = 0;
-    this.end = false;
-    let tree = document.getElementById("structureTree");
-    let node = (this.$refs.structureTree as any).store.root;
-
-    this.countExpandNode(node, id);
-    let count = this.count;
-    let parentElement = tree.parentElement;
-    parentElement.scrollTo(0, count * 26 - 60);
-  }
-
-  // TODO：递归待优化，找到目标节点应该中断递归
-  countExpandNode(node, id) {
-    if (!this.end) {
-      if (node.expanded || this.count === 0 || node.data.id === id) {
-        this.count += 1;
-        if (node.data && node.data.id === id) {
-          this.end = true;
-          return this.count;
-        }
-        if (node.childNodes) {
-          for (let i = 0, len = node.childNodes.length; i < len; i++) {
-            // 遍历子节点
-            this.countExpandNode(node.childNodes[i], id);
-          }
-        }
-      } else {
-        this.count += 1;
-      }
-    }
-  }
-
-  findRoVisible(insObj: Longan.RenderInstanceObject, checkedNos: number[]) {
-    if (insObj.renderObject.visible) {
-      checkedNos.push(insObj.no);
-    }
-    for (let i = 0; i < insObj.childObjects.length; i++) {
-      this.findRoVisible(insObj.childObjects[i], checkedNos);
-    }
-  }
-
-  searchValueChange(val) {
-    if (val) {
-      let treeNodeObjects = this.viewer.structureTreeManager.treeNodeObjectHash;
-      let tree = this.$refs.structureTree as any;
-      // this.isLoading = true;
-
-      // let searchValue = this.searchValue.toLowerCase();
-      for (let key in treeNodeObjects) {
-        if (treeNodeObjects[key].name.toLowerCase().indexOf(this.searchValue) !== -1) {
-          let treeNodeObject = treeNodeObjects[key];
-          let pathKeys: Longan.List<string> = new Longan.List();
-          if (treeNodeObject) {
-            this.getPathKeys(treeNodeObject, pathKeys);
-          }
-
-          pathKeys.items.reverse().forEach((id) => {
-            setTimeout(() => {
-              let node = tree.getNode(id);
-              if (node) {
-                node.expand();
-              }
-            }, 0);
-          });
-        }
-      }
-    }
-    setTimeout(() => {
-      (this.$refs.structureTree as any).filter(this.searchValue);
-      // this.isLoading = false;
-    }, 0);
-  }
-
-  filterNode(value, data): boolean {
-    if (!value) {
-      return true;
-    }
-    return data.name.indexOf(value) !== -1;
-  }
-
-  treeCheck(data: TreeNodeObject, { checkedNodes, checkedKeys, halfCheckedNodes, halfCheckedKeys }) {
-    this.isChecking = true;
-    let treeNodeObject = this.viewer.structureTreeManager.getTreeNodeById(data.id);
-    let isUpdate = false;
-    if (checkedNodes.map((item) => item.id).indexOf(treeNodeObject.id) === -1) {
-      treeNodeObject.invisible(false);
-      isUpdate = true;
-    } else {
-      checkedNodes.map((item) => {
-        let checkTreeNodeObject = this.viewer.structureTreeManager.getTreeNodeById(item.id);
-        checkTreeNodeObject.visible(false);
-        isUpdate = true;
-      });
-    }
-
-    if (isUpdate) {
-      setTimeout(() => {
-        this.viewer.styleManager.updateAllStyle().then(() => {
-          this.isChecking = false;
-        });
-      }, 10);
-    }
-
-    if (this.viewer.options.components.structureTree.defaultTab.checkFun) {
-      this.viewer.options.components.structureTree.defaultTab.checkFun(treeNodeObject, {
-        checkedNodes,
-        checkedKeys,
-        halfCheckedNodes,
-        halfCheckedKeys,
-      });
-    }
-  }
-
-  findInvisibleRootNodes(rootNode, halfCheckedNodes, invisibleRootNodes) {
-    if (rootNode.checked === false) {
-      if (halfCheckedNodes.indexOf(rootNode.data) === -1) {
-        invisibleRootNodes.push(rootNode.data);
-      } else {
-        let childNodes = rootNode.childNodes;
-        for (let i = 0; i < childNodes.length; i++) {
-          this.findInvisibleRootNodes(childNodes[i], halfCheckedNodes, invisibleRootNodes);
-        }
-      }
-    }
-  }
-
-  treeNodeClick(data, node) {
-    this.isChecking = true;
-
-    let treeNode = this.viewer.structureTreeManager.getTreeNodeById(data.id);
-
-    console.log("treeNodeClick", treeNode);
-    this.currentTreeNodeData = treeNode;
-
-    console.time("构件高亮");
-    if (treeNode) {
-      this.viewer.selectionManager.clearSelectionAndHighlight();
-      // treeNode.highlight(true);
-      this.viewer.selectionManager.selectAndHighlight(treeNode);
-      setTimeout(() => {
-        this.viewer.styleManager.updateAllStyle().then(() => {
-          console.time("treeNode.locate");
-          treeNode.locate();
-          console.timeEnd("treeNode.locate");
-          this.isChecking = false;
-        });
-      }, 10);
-
-      let panel = this.viewer.panelManager.getPanelByName<PropertyPanel>("PropertyPanel");
-      if (panel) {
-        panel.getProperty(treeNode);
-      }
-    }
-    console.timeEnd("构件高亮");
-
-    if (this.viewer.options.components.structureTree.clickFun) {
-      this.viewer.options.components.structureTree.clickFun(treeNode);
-    }
-    if (this.viewer.options.components.structureTree.defaultTab.clickFun) {
-      this.viewer.options.components.structureTree.defaultTab.clickFun(treeNode);
-    }
-    // this.viewer.updateDisplay();
-  }
-
-  createTree(newTree, node) {
-    let newNode = null;
-    if (node.data) {
-      newNode = { key: node.data.key, name: node.data.name, items: [] };
-      if (newTree.items) {
-        newTree.items.push(newNode);
-      } else {
-        newTree.push(newNode);
-      }
-    }
-
-    if (!newNode) {
-      newNode = newTree;
-    }
-
-    for (let i = 0; i < node.childNodes.length; i++) {
-      this.createTree(newNode, node.childNodes[i]);
-    }
-  }
-
-  getProperties(key) {
-    let segment = new Longan.Segment(key);
-    let jsonString = segment.property.showString("Properties");
-
-    let showParentProperty = segment.property.showBoolean("showParentProperties");
-    if (showParentProperty) {
-      let key = segment.owner.key;
-      jsonString = this.getParentProperties(key);
-    }
-
-    return JSON.parse(jsonString);
-  }
-
-  getParentProperties(key) {
-    let segment = new Longan.Segment(key);
-    let properties = segment.property.showString("Properties");
-    if (properties) {
-      return properties;
-    } else {
-      return this.getParentProperties(segment.owner.key);
-    }
-  }
-
-  treeNodeDragStart(node, ev) {
-    this.draggingNode = node;
-    this.currentTreeNode = node;
-    this.currentTreeNodeData = this.viewer.structureTreeManager.treeNodeObjectHash[node.data.id];
-    this.draggingNodeChecked = node.checked;
-
-    console.log("this.draggingNodeChecked ", this.draggingNodeChecked);
-  }
-
-  treeNodeDragEnter(draggingNode, overNode, ev) {
-    // this.loadNode(overNode, this.level0NodeResolve);
-    console.log("this.treeNodeDragEnterTimer");
-    // if (this.treeNodeDragEnterTimer) {
-    //   clearTimeout(this.treeNodeDragEnterTimer);
-    // }
-    // this.treeNodeDragEnterTimer = setTimeout(() => {
-    //   this.expandedKeys.push(overNode.data.id);
-    //   clearTimeout(this.treeNodeDragEnterTimer);
-    //   this.treeNodeDragEnterTimer = null;
-    // }, 500);
-  }
-
-  treeNodeDragEnd(draggingNode, dropNode, dropType) {
-    // if (dropType === "inner" && !dropNode.expanded) {
-    //   this.$message.warning(dropNode.label + "节点未展开，无法移入");
-    //   return false;
-    // }
-    // return true;
-  }
-
-  treeNodeDrop(draggingNode, dropNode, dropType, ev) {
-    console.log("dropNode.expend", dropNode);
-
-    this.$confirm(
-      `是否将节点${draggingNode.label}移动到${dropNode.label}${
-        dropType == "before" ? "之前" : dropType == "after" ? "之后" : "下"
-      }?`,
-      "提示",
-      {
-        confirmButtonText: "确定",
-        cancelButtonText: "取消",
-        type: "warning",
-      }
-    )
-      .then(() => {
-        this.dropConfirm(draggingNode, dropNode, dropType).then(() => {
-          this.$message({
-            type: "success",
-            message: "移动成功!",
-          });
-          // structureTreeBus.$emit("updateTree", draggingNode.key);
-          if (dropNode === "inner") {
-            structureTreeBus.$emit("updateTree", dropNode.key);
-          } else {
-            structureTreeBus.$emit("updateTree", dropNode.parent.key);
-          }
-        });
-      })
-      .catch(() => {
-        this.$message({
-          type: "info",
-          message: "取消移动",
-        });
-        // structureTreeBus.$emit("updateTree", draggingNode.parent.key);
-        structureTreeBus.$emit("updateTree", dropNode.parent.key);
-      });
-  }
-
-  dropConfirm(draggingNode, dropNode, dropType) {
-    function getIndex(parent, child) {
-      for (let i = 0, len = parent.childNodes.length; i < len; i++) {
-        const item = parent.childNodes[i];
-        if (item.key === child.key) {
-          return i;
-        }
-      }
-      return -1;
-    }
-
-    let index = -1;
-    // let draggingSegment = new LonganApi.Segment(draggingNode.key);
-    let dropSegment;
-
-    let draggingTreeNode = this.viewer.structureTreeManager.treeNodeObjectHash[draggingNode.data.id];
-    let dropTreeNode;
-
-    let targetSegIndex;
-
-    switch (dropType) {
-      case "inner":
-        // dropSegment = new LonganApi.Segment(dropNode.key);
-        dropTreeNode = this.viewer.structureTreeManager.treeNodeObjectHash[dropNode.data.id];
-        dropSegment = dropTreeNode.segment;
-        targetSegIndex = dropTreeNode.childNodes.length;
-        this.expandedKeys.push(dropNode.data.key);
-        break;
-      case "before":
-        index = getIndex(dropNode.parent, dropNode);
-        // dropSegment = new LonganApi.Segment(dropNode.parent.key);
-        dropTreeNode = this.viewer.structureTreeManager.treeNodeObjectHash[dropNode.parent.data.id];
-        // dropSegment =
-        //   this.viewer.structureTreeManager.treeNodeObjects[dropNode.key].segment
-        //     .owner;
-        targetSegIndex = index - 1;
-
-        break;
-      case "after":
-        index = getIndex(dropNode.parent, dropNode);
-
-        dropTreeNode = this.viewer.structureTreeManager.treeNodeObjectHash[dropNode.parent.data.id];
-
-        targetSegIndex = index + 1;
-        break;
-    }
-    return draggingTreeNode.moveToWithRequestApi(dropTreeNode, targetSegIndex);
-  }
-
-  addTreeNodeClick() {
-    let data = this.currentTreeNodeData;
-    if (data.childNodes) {
-      for (let i = 0; i < data.childNodes.length; i++) {
-        if (data.childNodes[i].id === "-1") {
-          return;
-        }
-      }
-    }
-
-    this.nameValue = "";
-
-    const parent = this.currentTreeNode;
-    parent.expand();
-    // this.expandedKeys.push(data.id);
-    // this.expandedKeys.push("-1");
-    (this.$refs.structureTree as any).append(
-      {
-        name: " ",
-        id: "-1",
-        isShow: true,
-      },
-      parent
-    );
-
-    this.isEditingKey = "-1";
-    setTimeout(() => {
-      this.locateCurrentNode("-1");
-      let input = this.$refs.editingTreeNodeInput as any;
-      if (input) {
-        input.focus();
-      }
-    }, 10);
-  }
-
-  renameTreeNodeClick() {
-    let data = this.currentTreeNodeData;
-    this.isEditingKey = data.id;
-    this.nameValue = data.name;
-    setTimeout(() => {
-      (this.$refs.editingTreeNodeInput as any).focus();
-    }, 10);
-  }
-
-  deleteTreeNodeClick() {
-    let data = this.currentTreeNodeData;
-    let node = this.currentTreeNode;
-    MessageBox.confirm(`确定删除${data.name}节点？`, "提示", {
-      confirmButtonText: "确定",
-      cancelButtonText: "取消",
-      type: "warning",
-    }).then(() => {
-      // this.updateIndexedDB();
-
-      this.currentTreeNodeData.deleteWithRequestApi().then(() => {
-        let children: any[] = node.parent.childNodes;
-        const index = children.findIndex((d) => d.data.id === node.data.id);
-
-        if (index >= 0) {
-          children.splice(index, 1);
-        } else {
-          this.$message.warning("节点删除出错");
-        }
-      });
-    });
-  }
-
-  editRenderObjectConfirm(node, data) {
-    let treeNode = this.viewer.structureTreeManager.treeNodeObjectHash[data.id];
-
-    // 添加
-    if (data.id === "-1") {
-      let segment = new LonganApi.Segment(this.parentSegmentKey);
-      if (!this.nameValue) {
-        Message.warning("节点名不能为空");
-        return;
-      }
-      if (segment.subsegmentExists(this.nameValue)) {
-        Message.warning("此节点已存在，请重命名");
-      } else {
-        // let parent = data.parent;
-        //删除临时的
-        // parent.removeChildNode(treeNode);
-        // treeNode.delete();
-        const parent = node.parent;
-        const children = parent.childNodes;
-        const index = children.findIndex((d) => d.id === data.id);
-        children.splice(index, 1);
-
-        let parentTreeNode = this.viewer.structureTreeManager.treeNodeObjectHash[parent.data.id];
-        console.log("parentTreeNode", parentTreeNode);
-        if (parentTreeNode) {
-          parentTreeNode.addWithRequestApi(this.nameValue, true).then((treeNodeObject) => {
-            if (treeNodeObject) {
-              // treeNode = treeNodeObject;
-              data.id = treeNodeObject.id;
-              data.name = treeNodeObject.name;
-              this.isEditingKey = null;
-              this.nameValue = "";
-              (this.$refs.structureTree as any).append(
-                {
-                  name: treeNodeObject.name,
-                  id: treeNodeObject.id,
-                  isShow: true,
-                },
-                parent
-              );
-              (this.$refs.structureTree as any).setChecked(data.id, true, true);
-              (this.$refs.structureTree as any).setChecked(treeNodeObject.id, true, true);
-              this.updateIndexedDB();
-            } else {
-              Message.error("添加失败");
-            }
-          });
-        }
-      }
-    } else {
-      // 编辑
-      if (this.nameValue) {
-        this.currentTreeNodeData.renameWithRequestApi(this.nameValue).then((treeNodeObject) => {
-          if (treeNodeObject) {
-            data.name = this.nameValue;
-            this.isEditingKey = null;
-            this.nameValue = "";
-          } else {
-            Message.error("编辑失败");
-          }
-        });
-      } else {
-        Message.warning("名字不能为空");
-      }
-    }
-  }
-
-  editRenderObjectCancel(node, data) {
-    // 添加
-    if (data.id === "-1") {
-      const parent = node.parent;
-      const children = parent.childNodes;
-      const index = children.findIndex((d) => d.id === data.id);
-      children.splice(index, 1);
-    } else {
-      // 编辑
-      this.isEditingKey = null;
-    }
-  }
-
-  updateIndexedDB() {}
-
-  treeNodeMouseOver(data) {
-    // if (this.isTreeEditing) {
-    this.treeNodeHoverKey = data.key;
-    // }
-  }
-
-  treeNodeMouseLeave(data) {
-    // if (this.isTreeEditing) {
-    this.treeNodeHoverKey = null;
-    // }
-  }
-
-  isBindModelExist(modelId) {
-    return false;
-  }
-
-  treeNodeContextMenuClick(e, data, node, nodeElement) {
-    let treeNodeObject = this.viewer.structureTreeManager.treeNodeObjectHash[data.id];
-    this.currentTreeNodeData = treeNodeObject;
-    this.currentTreeNode = node;
-    console.log("treeNodeContextMenuClick", treeNodeObject, node);
-
-    createMenu(e.pageX, e.pageY, this.buttonList);
-  }
-
-  treeNodeExpand(data, node, e) {
-    console.log(data, node, e);
-    this.expandedKeys.push(data.id);
-  }
-
-  treeNodeCollapse(data, node, e) {
-    let index = this.expandedKeys.indexOf(data.id);
-    if (index !== -1) {
-      this.expandedKeys.splice(index, 1);
-    }
-  }
-
-  showLevel(level: number) {
-    setTimeout(() => {
-      // this.expandedKeys = [];
-      let node = this.currentTreeNodeData;
-      this.expandLevel(node, level);
-    }, 10);
-  }
-
-  expandLevel(node, level: number) {
-    // node.expanded = true;
-    if (node) {
-      node.loaded = false;
-
-      let nodeDom = (this.$refs.structureTree as any)?.getNode(node.id);
-      if (nodeDom) {
-        nodeDom.expand();
-      }
-    }
-    setTimeout(() => {
-      let currentLevel = level - 1;
-      if (currentLevel > 0) {
-        for (let i = 0; i < node.childNodes.length; i++) {
-          const item = node.childNodes[i];
-          if (item.childNodes && item.childNodes.length > 0) {
-            this.expandLevel(item, currentLevel);
-          }
-        }
-      }
-    }, 10);
-    // this.expandedKeys.push(node.key);
-  }
-
-  setAllExpand(state) {
-    let nodes = (this.$refs.structureTree as any).store.root;
-    this.expandNode(nodes, state);
-  }
-
-  expandNode(node, state) {
-    // 改变节点的自身expanded状态
-    node.expanded = state;
-    for (let i = 0, len = node.childNodes.length; i < len; i++) {
-      // 遍历子节点
-      if (node.childNodes[i].childNodes.length > 0) {
-        this.expandNode(node.childNodes[i], state);
-      }
-    }
-  }
-
-  hideObject() {
-    console.log("hideObject");
-    // (this.$refs.structureTree as any).setChecked(this.currentTreeNodeData, false, true);
-    structureTreeBus.$emit("unCheckTreeNode", this.currentTreeNodeData);
-    this.viewer.styleManager.invisible(this.currentTreeNodeData);
-    this.viewer.styleManager.updateAllStyle();
-  }
-
-  reHideObject() {
-    structureTreeBus.$emit("reCheckTreeNode", this.currentTreeNodeData);
-
-    this.viewer.styleManager.invisible(...this.viewer.structureTreeManager.treeNodeObjects);
-    this.viewer.styleManager.clearInvisible(this.currentTreeNodeData);
-    this.viewer.styleManager.updateAllStyle();
-  }
-
-  clearHideObject() {
-    structureTreeBus.$emit("checkAllTreeNode", this.currentTreeNodeData);
-
-    this.viewer.styleManager.clearInvisible();
-    this.viewer.styleManager.updateAllStyle();
-  }
-
-  // checkChange(data) {
-  //   let checkedNodes;
-  //   let checkedKeys = (this.$refs.structureTree as any).getCheckedKeys();
-  //   let halfCheckedNodes = (this.$refs.structureTree as any).getHalfCheckedNodes();
-  //   let halfCheckedKeys;
-  //   this.treeCheck(data, {
-  //     checkedNodes,
-  //     checkedKeys,
-  //     halfCheckedNodes,
-  //     halfCheckedKeys,
-  //   });
-  // }
-
-  isolateObject() {
-    this.viewer.styleManager.isolation(this.currentTreeNodeData);
-    this.viewer.styleManager.updateAllStyle();
-  }
-
-  isolateOtherObjects() {
-    this.viewer.styleManager.isolation(...this.viewer.structureTreeManager.treeNodeObjects);
-    this.viewer.styleManager.clearIsolation(this.currentTreeNodeData);
-    this.viewer.styleManager.updateAllStyle();
-  }
-
-  clearIsolateObjects() {
-    this.viewer.styleManager.clearIsolation();
-    this.viewer.styleManager.updateAllStyle();
-  }
-
-  openEditAllRenderObjectClick(node, data) {}
-
-  editAllRenderObjectConfirm(data) {
-    this.isTreeEditing = false;
-    this.treeNodeHoverKey = null;
-  }
-
-  editAllRenderObjectCancel(data) {
-    // this.isTreeEditing = false;
-    // this.treeNodeHoverKey = null;
-    // this.modelObjects = [...this.modelObjectsClone];
-    // this.getModelObjects();
-    // this.modelObjects = [];
-    // this.createTree(this.modelObjects, (this.$refs.structureTree as any).root);
-  }
-
-  setData() {
-    this.$emit("setData", {
-      title: "模型结构树",
-      top: "20px",
-      left: "20px",
-      height: "600px",
-      width: "300px",
-    });
-  }
-
-  findTreeNodePath(node, targetKey, nodePath: any[]) {
-    if (!this.loopFlag) {
-      return;
-    }
-    let childNodes = node.childNodes;
-    for (let i = 0; i < childNodes.length; i++) {
-      let childNode = childNodes[i];
-      let data = childNode.data;
-
-      let deepCloneNodePath = [...nodePath];
-
-      deepCloneNodePath.push(childNode);
-      if (data.key !== targetKey) {
-        this.findTreeNodePath(childNode, targetKey, deepCloneNodePath);
-      } else {
-        this.nodePath.push(this.rootNode);
-        for (let j = 0; j < deepCloneNodePath.length; j++) {
-          this.nodePath.push(deepCloneNodePath[j]);
-        }
-        this.selectedGslNode = childNode;
-        this.loopFlag = false;
-        return deepCloneNodePath;
-      }
-    }
-  }
-
-  getPathKeys(treeNodeObject: TreeNodeObject, pathKeys: Longan.List<string>) {
-    if (treeNodeObject.id) {
-      pathKeys.add(treeNodeObject.id);
-    }
-    if (treeNodeObject.parent) {
-      this.getPathKeys(treeNodeObject.parent, pathKeys);
-    }
-  }
-
-  updateNode(treeNodeObject: TreeNodeObject) {
-    let pathKeys: Longan.List<string> = new Longan.List();
-    if (treeNodeObject) {
-      this.getPathKeys(treeNodeObject, pathKeys);
-    }
-
-    // let tree = this.$refs.structureTree as any;
-    pathKeys.items.reverse().forEach((id) => {
-      if (id === this.level0Node.key) {
-        this.loadNode(this.level0Node, this.level0NodeResolve);
-      } else {
-        this.loadNode(this.currentNode, this.currentNodeResolve);
-      }
-    });
-  }
-
-  mounted() {
-    this.setData();
-
-    this.isTreeLoading = true;
-    let timer = setInterval(() => {
-      if (this.viewer.structureTreeManager.treeNodeObjects.length > 0) {
-        this.isTreeLoading = false;
-
-        // this.getModelObjects();
-        structureTreeBus.$on("unCheckTreeNode", (...treeNodeObjects: TreeNodeObject[]) => {
-          treeNodeObjects.forEach((treeNodeObject) => {
-            (this.$refs.structureTree as any).setChecked(treeNodeObject, false, true);
-          });
-        });
-
-        structureTreeBus.$on("reCheckTreeNode", (...treeNodeObjects: TreeNodeObject[]) => {
-          let root = (this.$refs.structureTree as any).root;
-          console.log("root-------------", root);
-          root.childNodes.forEach((item) => {
-            (this.$refs.structureTree as any).setChecked(item.data.id, false, true);
-          });
-          treeNodeObjects.forEach((treeNodeObject) => {
-            (this.$refs.structureTree as any).setChecked(treeNodeObject, true, true);
-          });
-        });
-
-        structureTreeBus.$on("checkAllTreeNode", () => {
-          let root = (this.$refs.structureTree as any).root;
-          root.childNodes.forEach((item) => {
-            (this.$refs.structureTree as any).setChecked(item.data.id, true, true);
-          });
-        });
-
-        structureTreeBus.$on("updateTree", (key?) => {
-          let tree: any = this.$refs.structureTree;
-          if (tree) {
-            // 获取当前选中节点的key值
-            let keys = tree.getCheckedKeys();
-            // 获取当前展开节点的key值
-            let expandedKeys = tree.getCheckedKeys();
-            // 更新数据
-            if (key !== undefined) {
-              let treeNode = this.viewer.structureTreeManager?.getTreeNodeById(key);
-
-              this.updateNode(treeNode);
-            } else {
-              this.level0Node.childNodes = []; //把存起来的node的子节点清空，不然会界面会出现重复树！
-              this.checkKeys = [];
-              this.loadNode(this.level0Node, this.level0NodeResolve);
-
-              this.showLevel(1);
-            }
-            // 重新勾选节点
-            // tree.setCheckedKeys(keys);
-            // 重新展开节点
-            tree.setCheckedKeys(expandedKeys);
-          }
-        });
-
-        this.$nextTick(() => {
-          let componentSelector = this.viewer.operatorManager.find("ComponentSelector") as ComponentSelector;
-          if (componentSelector) {
-            // this.viewer.onLButtonUp.add(this.heighLight);
-            this.heighLightObserver = componentSelector.lButtonUp.add((event: ViewerEvent) => {
-              // let segObj = this.viewer.selectionManager.selectedObject;
-              let treeNodeObject = (event.viewer as Viewer).selectionManager.selectedObject;
-              console.log("选中的对象：", treeNodeObject);
-              if (treeNodeObject) {
-                let pathKeys: Longan.List<string> = new Longan.List();
-                if (treeNodeObject) {
-                  this.getPathKeys(treeNodeObject, pathKeys);
-                }
-                let tree = this.$refs.structureTree as any;
-                // for (let i = 0; i < treeNodeObject.roIds.length; i++) {
-                //   let id = treeNodeObject.roIds[i];
-                //   let sceneTree = this.viewer.process.projectManager.sceneTree;
-                //   sceneTree.forEach((co) => {
-                //     if (co.id === id) {
-                //       console.log("co:", co.name);
-                //     }
-                //   });
-                // }
-                if (tree) {
-                  pathKeys.items.reverse().forEach((id) => {
-                    // 节点加载完后再展开
-                    setTimeout(() => {
-                      let node = tree.getNode(id);
-                      if (node) {
-                        node.expand();
-                      }
-                    }, 0);
-                  });
-                  // this.expandedKeys.push(segObj.id);
-                  setTimeout(() => {
-                    this.locateCurrentNode(treeNodeObject.id);
-                    tree.setCurrentKey(treeNodeObject.id);
-                  }, 10);
-                }
-              }
-            });
-          }
-        });
-        clearInterval(timer);
-      }
-    }, 200);
-  }
-
-  beforeDestroy() {
-    if (this.viewer) {
-      let componentSelector = this.viewer.operatorManager.find("ComponentSelector") as ComponentSelector;
-      if (componentSelector) {
-        componentSelector.lButtonDown.remove(this.heighLightObserver);
-      }
-    }
-  }
-}