csyjk 1.1.1 → 1.2.2

package/src/lib/gltf/assets/yjkkit-sdk/src/plugins/TreeViewPlugin/ModelTreeView.js

@@ -0,0 +1,888 @@
+import {Map} from "./../../viewer/scene/utils/Map.js";
+import {
+    validateMetaModelForTreeViewContainmentHierarchy,
+    validateMetaModelForTreeViewStoreysHierarchy, validateMetaModelForTreeViewTypesHierarchy
+} from "./modelValidation.js";
+
+const idMap = new Map();
+
+/**
+ * @desc Represents a model tree view within a {@link TreeViewPlugin}.
+ *
+ * * Stored in {@link treeViewPlugin#modelTreeViews}, mapped to the model ID.
+ * * Created by each call to {@link TreeViewPlugin#addModel}.
+ */
+class ModelTreeView {
+
+    /**
+     * @private
+     */
+    constructor(viewer, treeViewPlugin, model, metaModel, cfg) {
+
+        if (!cfg.containerElement) {
+            throw "Config expected: containerElement";
+        }
+
+        const rootMetaObject = metaModel.rootMetaObject;
+        if (!rootMetaObject) {
+            return;
+        }
+
+        /**
+         * Contains messages for any errors found in the MetaModel for this ModelTreeView.
+         * @type {String[]}
+         */
+        this.errors = [];
+
+        /**
+         * True if errors were found in the MetaModel for this ModelTreeView.
+         * @type {boolean}
+         */
+        this.valid = true;
+
+        /**
+         * The MetaModel corresponding to this ModelTreeView.
+         * @type {MetaModel}
+         */
+        this.metaModel = metaModel;
+
+        this._id = idMap.addItem();
+        this._baseId = "" + this._id;
+        this._viewer = viewer;
+        this._treeViewPlugin = treeViewPlugin;
+        this._rootMetaObject = rootMetaObject;
+        this._containerElement = cfg.containerElement;
+        this._rootElement = null;
+        this._muteSceneEvents = false;
+        this._muteTreeEvents = false;
+        this._rootNodes = [];
+        this._objectNodes = {};
+        this._rootName = cfg.rootName;
+        this._sortNodes = cfg.sortNodes;
+        this._pruneEmptyNodes = cfg.pruneEmptyNodes;
+
+        this._showListItemElementId = null;
+
+        this._containerElement.oncontextmenu = (e) => {
+            e.preventDefault();
+        };
+
+        this._onObjectVisibility = this._viewer.scene.on("objectVisibility", (entity) => {
+            if (this._muteSceneEvents) {
+                return;
+            }
+            const objectId = entity.id;
+            const node = this._objectNodes[objectId];
+            if (!node) {
+                return; // Not in this tree
+            }
+            const visible = entity.visible;
+            const updated = (visible !== node.checked);
+            if (!updated) {
+                return;
+            }
+            this._muteTreeEvents = true;
+            node.checked = visible;
+            if (visible) {
+                node.numVisibleEntities++;
+            } else {
+                node.numVisibleEntities--;
+            }
+            const checkbox = document.getElementById(node.nodeId);
+            if (checkbox) {
+                checkbox.checked = visible;
+            }
+            let parent = node.parent;
+            while (parent) {
+                parent.checked = visible;
+                if (visible) {
+                    parent.numVisibleEntities++;
+                } else {
+                    parent.numVisibleEntities--;
+                }
+                const parentCheckbox = document.getElementById(parent.nodeId);
+                if (parentCheckbox) {
+                    const newChecked = (parent.numVisibleEntities > 0);
+                    if (newChecked !== parentCheckbox.checked) {
+                        parentCheckbox.checked = newChecked;
+                    }
+                }
+                parent = parent.parent;
+            }
+            this._muteTreeEvents = false;
+        });
+
+        this.switchExpandHandler = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            const switchElement = event.target;
+            this._expandSwitchElement(switchElement);
+        };
+
+        this.switchCollapseHandler = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            const switchElement = event.target;
+            this._collapseSwitchElement(switchElement);
+        };
+
+        this._checkboxChangeHandler = (event) => {
+            if (this._muteTreeEvents) {
+                return;
+            }
+            this._muteSceneEvents = true;
+            const checkbox = event.target;
+            const visible = checkbox.checked;
+            const nodeId = checkbox.id;
+            const checkedObjectId = this._nodeToObjectID(nodeId);
+            const checkedNode = this._objectNodes[checkedObjectId];
+            const objects = this._viewer.scene.objects;
+            let numUpdated = 0;
+            this._withNodeTree(checkedNode, (node) => {
+                const objectId = node.objectId;
+                const checkBoxId = node.nodeId;
+                const entity = objects[objectId];
+                const isLeaf = (node.children.length === 0);
+                node.numVisibleEntities = visible ? node.numEntities : 0;
+                if (isLeaf && (visible !== node.checked)) {
+                    numUpdated++;
+                }
+                node.checked = visible;
+                const checkbox2 = document.getElementById(checkBoxId);
+                if (checkbox2) {
+                    checkbox2.checked = visible;
+                }
+                if (entity) {
+                    entity.visible = visible;
+                }
+            });
+            let parent = checkedNode.parent;
+            while (parent) {
+                parent.checked = visible;
+                const checkbox2 = document.getElementById(parent.nodeId); // Parent checkboxes are always in DOM
+                if (visible) {
+                    parent.numVisibleEntities += numUpdated;
+                } else {
+                    parent.numVisibleEntities -= numUpdated;
+                }
+                const newChecked = (parent.numVisibleEntities > 0);
+                if (newChecked !== checkbox2.checked) {
+                    checkbox2.checked = newChecked;
+                }
+                parent = parent.parent;
+            }
+            this._muteSceneEvents = false;
+        };
+
+        this._hierarchy = cfg.hierarchy || "containment";
+        this._autoExpandDepth = cfg.autoExpandDepth || 0;
+
+        this._createNodes();
+    }
+
+    _nodeToObjectID(nodeId) {
+        return nodeId.substring(this._baseId.length);
+    }
+
+    _objectToNodeID(objectId) {
+        return this._baseId + objectId;
+    }
+
+    /**
+     * @private
+     * @param depth
+     */
+    setAutoExpandDepth(depth = 0) {
+        this._autoExpandDepth = depth;
+    }
+
+    /**
+     * @private
+     * @param hierarchy
+     */
+    setHierarchy(hierarchy) {
+        if (this._hierarchy === hierarchy) {
+            return;
+        }
+        this._hierarchy = hierarchy;
+        this._createNodes();
+    }
+
+    _createNodes() {
+        if (this._rootElement) {
+            this._rootElement.parentNode.removeChild(this._rootElement);
+            this._rootElement = null;
+        }
+        this._rootNodes = [];
+        this._objectNodes = {};
+        this._validate();
+        if (this.valid) {
+            this._createEnabledNodes();
+        } else {
+            this._createDisabledNodes();
+        }
+    }
+
+    _validate() {
+        this.errors = [];
+        switch (this._hierarchy) {
+            case "storeys":
+                this.valid = validateMetaModelForTreeViewStoreysHierarchy(this.metaModel, this.errors);
+                break;
+            case "types":
+                this.valid = validateMetaModelForTreeViewTypesHierarchy(this.metaModel, this.errors);
+                break;
+            case "containment":
+            default:
+                this.valid = validateMetaModelForTreeViewContainmentHierarchy(this.metaModel, this.errors);
+                break;
+        }
+        return this.valid;
+    }
+
+    _createEnabledNodes() {
+        if (this._pruneEmptyNodes) {
+            this._findEmptyNodes();
+        }
+        switch (this._hierarchy) {
+            case "storeys":
+                this._createStoreysNodes();
+                if (this._rootNodes.length === 0) {
+                    this._treeViewPlugin.error("Failed to build storeys hierarchy for model '" + this.metaModel.id + "' - perhaps this model is not an IFC model?");
+                }
+                break;
+            case "types":
+                this._createTypesNodes();
+                break;
+            case "containment":
+            default:
+                this._createContainmentNodes();
+        }
+        if (this._sortNodes) {
+            this._doSortNodes();
+        }
+        this._synchNodesToEntities();
+        this._createTrees();
+        this.expandToDepth(this._autoExpandDepth);
+    }
+
+    _createDisabledNodes() {
+
+        const metaObject = this._rootMetaObject;
+        const metaObjectType = metaObject.type;
+        const metaObjectName = metaObject.name;
+
+        const rootName = ((metaObjectName && metaObjectName !== "" && metaObjectName !== "Undefined" && metaObjectName !== "Default") ? metaObjectName : metaObjectType);
+
+        const ul = document.createElement('ul');
+        const li = document.createElement('li');
+        ul.appendChild(li);
+        this._containerElement.appendChild(ul);
+        this._rootElement = ul;
+
+        const switchElement = document.createElement('a');
+        switchElement.href = '#';
+        switchElement.textContent = '!';
+        switchElement.classList.add('warn');
+        switchElement.classList.add('warning');
+        li.appendChild(switchElement);
+
+        const span = document.createElement('span');
+        span.textContent = rootName;
+        li.appendChild(span);
+    }
+
+    _findEmptyNodes(metaObject = this._rootMetaObject, countEntities = 0) {
+        const viewer = this._treeViewPlugin.viewer;
+        const scene = viewer.scene;
+        const children = metaObject.children;
+        const objectId = metaObject.id;
+        const entity = scene.objects[objectId];
+        metaObject._countEntities = 0;
+        if (entity) {
+            metaObject._countEntities++;
+        }
+        if (children) {
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childMetaObject = children[i];
+                childMetaObject._countEntities = this._findEmptyNodes(childMetaObject);
+                metaObject._countEntities += childMetaObject._countEntities;
+            }
+        }
+        return metaObject._countEntities;
+    }
+
+    _createStoreysNodes(
+        metaObject = this._rootMetaObject,
+        buildingNode,
+        storeyNode,
+        typeNodes) {
+        if (this._pruneEmptyNodes && (metaObject._countEntities === 0)) {
+            return;
+        }
+        const metaObjectType = metaObject.type;
+        const metaObjectName = metaObject.name;
+        const children = metaObject.children;
+        const objectId = metaObject.id;
+        if (metaObjectType === "IfcBuilding") {
+            buildingNode = {
+                nodeId: this._objectToNodeID(objectId),
+                objectId: objectId,
+                title: this._rootName || ((metaObjectName && metaObjectName !== "" && metaObjectName !== "Undefined" && metaObjectName !== "Default") ? metaObjectName : metaObjectType),
+                type: metaObjectType,
+                parent: null,
+                numEntities: 0,
+                numVisibleEntities: 0,
+                checked: false,
+                children: []
+            };
+            this._rootNodes.push(buildingNode);
+            this._objectNodes[buildingNode.objectId] = buildingNode;
+        } else if (metaObjectType === "IfcBuildingStorey") {
+            if (!buildingNode) {
+                this._treeViewPlugin.error("Failed to build storeys hierarchy for model '" + this.metaModel.id + "' - model does not have an IfcBuilding object, or is not an IFC model");
+                return;
+            }
+            storeyNode = {
+                nodeId: this._objectToNodeID(objectId),
+                objectId: objectId,
+                title: (metaObjectName && metaObjectName !== "" && metaObjectName !== "Undefined" && metaObjectName !== "Default") ? metaObjectName : metaObjectType,
+                type: metaObjectType,
+                parent: buildingNode,
+                numEntities: 0,
+                numVisibleEntities: 0,
+                checked: false,
+                children: []
+            };
+            buildingNode.children.push(storeyNode);
+            this._objectNodes[storeyNode.objectId] = storeyNode;
+            typeNodes = {};
+        } else {
+            if (storeyNode) {
+                const objects = this._viewer.scene.objects;
+                const object = objects[objectId];
+                if (object) {
+                    typeNodes = typeNodes || {};
+                    let typeNode = typeNodes[metaObjectType];
+                    if (!typeNode) {
+                        const typeNodeObjectId = storeyNode.objectId + "." + metaObjectType;
+                        const typeNodeNodeId = this._objectToNodeID(typeNodeObjectId);
+                        typeNode = {
+                            nodeId: typeNodeNodeId,
+                            objectId: typeNodeObjectId,
+                            title: metaObjectType,
+                            type: metaObjectType,
+                            parent: storeyNode,
+                            numEntities: 0,
+                            numVisibleEntities: 0,
+                            checked: false,
+                            children: []
+                        };
+                        storeyNode.children.push(typeNode);
+                        this._objectNodes[typeNodeObjectId] = typeNode;
+                        typeNodes[metaObjectType] = typeNode;
+                    }
+                    const node = {
+                        nodeId: this._objectToNodeID(objectId),
+                        objectId: objectId,
+                        title: (metaObjectName && metaObjectName !== "" && metaObjectName !== "Undefined" && metaObjectName !== "Default") ? metaObjectName : metaObjectType,
+                        type: metaObjectType,
+                        parent: typeNode,
+                        numEntities: 0,
+                        numVisibleEntities: 0,
+                        checked: false,
+                        children: []
+                    };
+                    typeNode.children.push(node);
+                    this._objectNodes[node.objectId] = node;
+                }
+            }
+        }
+        if (children) {
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childMetaObject = children[i];
+                this._createStoreysNodes(childMetaObject, buildingNode, storeyNode, typeNodes);
+            }
+        }
+    }
+
+    _createTypesNodes(metaObject = this._rootMetaObject, rootNode, typeNodes) {
+        if (this._pruneEmptyNodes && (metaObject._countEntities === 0)) {
+            return;
+        }
+        const metaObjectType = metaObject.type;
+        const metaObjectName = metaObject.name;
+        const children = metaObject.children;
+        const objectId = metaObject.id;
+        if (metaObject.id === this._rootMetaObject.id) {
+            rootNode = {
+                nodeId: this._objectToNodeID(objectId),
+                objectId: objectId,
+                title: this._rootName || ((metaObjectName && metaObjectName !== "" && metaObjectName !== "Undefined" && metaObjectName !== "Default") ? metaObjectName : metaObjectType),
+                type: metaObjectType,
+                parent: null,
+                numEntities: 0,
+                numVisibleEntities: 0,
+                checked: false,
+                children: []
+            };
+            this._rootNodes.push(rootNode);
+            this._objectNodes[rootNode.objectId] = rootNode;
+            typeNodes = {};
+        } else {
+            if (rootNode) {
+                const objects = this._viewer.scene.objects;
+                const object = objects[objectId];
+                if (object) {
+                    let typeNode = typeNodes[metaObjectType];
+                    if (!typeNode) {
+                        typeNode = {
+                            nodeId: this._objectToNodeID(rootNode.objectId + "." + metaObjectType),
+                            objectId: rootNode.objectId + "." + metaObjectType,
+                            title: metaObjectType,
+                            type: metaObjectType,
+                            parent: rootNode,
+                            numEntities: 0,
+                            numVisibleEntities: 0,
+                            checked: false,
+                            children: []
+                        };
+                        rootNode.children.push(typeNode);
+                        this._objectNodes[typeNode.objectId] = typeNode;
+                        typeNodes[metaObjectType] = typeNode;
+                    }
+                    const node = {
+                        nodeId: this._objectToNodeID(objectId),
+                        objectId: objectId,
+                        title: (metaObjectName && metaObjectName !== "" && metaObjectName !== "Default") ? metaObjectName : metaObjectType,
+                        type: metaObjectType,
+                        parent: typeNode,
+                        numEntities: 0,
+                        numVisibleEntities: 0,
+                        checked: false,
+                        children: []
+                    };
+                    typeNode.children.push(node);
+                    this._objectNodes[node.objectId] = node;
+                }
+            }
+        }
+        if (children) {
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childMetaObject = children[i];
+                this._createTypesNodes(childMetaObject, rootNode, typeNodes);
+            }
+        }
+    }
+
+    _createContainmentNodes(metaObject = this._rootMetaObject, parent) {
+        if (this._pruneEmptyNodes && (metaObject._countEntities === 0)) {
+            return;
+        }
+        const metaObjectType = metaObject.type;
+        const metaObjectName = metaObject.name || metaObjectType;
+        const children = metaObject.children;
+        const objectId = metaObject.id;
+        const node = {
+            nodeId: this._objectToNodeID(objectId),
+            objectId: objectId,
+            title: (!parent) ? (this._rootName || metaObjectName) : (metaObjectName && metaObjectName !== "" && metaObjectName !== "Undefined" && metaObjectName !== "Default") ? metaObjectName : metaObjectType,
+            type: metaObjectType,
+            parent: parent,
+            numEntities: 0,
+            numVisibleEntities: 0,
+            checked: false,
+            children: []
+        };
+        if (parent) {
+            parent.children.push(node);
+        } else {
+            this._rootNodes.push(node);
+        }
+        this._objectNodes[node.objectId] = node;
+
+        if (children) {
+            for (let i = 0, len = children.length; i < len; i++) {
+                const childMetaObject = children[i];
+                this._createContainmentNodes(childMetaObject, node);
+            }
+        }
+    }
+
+    _doSortNodes() {
+        for (let i = 0, len = this._rootNodes.length; i < len; i++) {
+            const rootNode = this._rootNodes[i];
+            this._sortChildren(rootNode);
+        }
+    }
+
+    _sortChildren(node) {
+        const children = node.children;
+        if (!children || children.length === 0) {
+            return;
+        }
+        if (this._hierarchy === "storeys" && node.type === "IfcBuilding") {
+            // Assumes that children of an IfcBuilding will always be IfcBuildingStoreys
+            children.sort(this._getSpatialSortFunc());
+        } else {
+            children.sort(this._alphaSortFunc);
+        }
+        for (let i = 0, len = children.length; i < len; i++) {
+            const node = children[i];
+            this._sortChildren(node);
+        }
+    }
+
+    _getSpatialSortFunc() { // Creates cached sort func with Viewer in scope
+        const viewer = this._treeViewPlugin.viewer;
+        const scene = viewer.scene;
+        const camera = scene.camera;
+        const metaScene = viewer.metaScene;
+        return this._spatialSortFunc || (this._spatialSortFunc = (node1, node2) => {
+            if (!node1.aabb || !node2.aabb) {
+                // Sorting on lowest point of the AABB is likely more more robust when objects could overlap storeys
+                if (!node1.aabb) {
+                    node1.aabb = scene.getAABB(metaScene.getObjectIDsInSubtree(node1.objectId));
+                }
+                if (!node2.aabb) {
+                    node2.aabb = scene.getAABB(metaScene.getObjectIDsInSubtree(node2.objectId));
+                }
+            }
+            let idx = 0;
+            if (camera.xUp) {
+                idx = 0;
+            } else if (camera.yUp) {
+                idx = 1;
+            } else {
+                idx = 2;
+            }
+            if (node1.aabb[idx] > node2.aabb[idx]) {
+                return -1;
+            }
+            if (node1.aabb[idx] < node2.aabb[idx]) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+
+    _alphaSortFunc(node1, node2) {
+        const title1 = node1.title.toUpperCase(); // FIXME: Should be case sensitive?
+        const title2 = node2.title.toUpperCase();
+        if (title1 < title2) {
+            return -1;
+        }
+        if (title1 > title2) {
+            return 1;
+        }
+        return 0;
+    }
+
+    _synchNodesToEntities() {
+        const rootMetaObject = this._rootMetaObject;
+        const objectIds = rootMetaObject.getObjectIDsInSubtree();
+        const metaObjects = this._viewer.metaScene.metaObjects;
+        const objects = this._viewer.scene.objects;
+        for (let i = 0, len = objectIds.length; i < len; i++) {
+            const objectId = objectIds[i];
+            const metaObject = metaObjects[objectId];
+            if (metaObject) {
+                const node = this._objectNodes[objectId];
+                if (node) {
+                    const entity = objects[objectId];
+                    if (entity) {
+                        const visible = entity.visible;
+                        node.numEntities = 1;
+                        if (visible) {
+                            node.numVisibleEntities = 1;
+                            node.checked = true;
+                        } else {
+                            node.numVisibleEntities = 0;
+                            node.checked = false;
+                        
+                        }
+                        let parent = node.parent; // Synch parents
+                        while (parent) {
+                            parent.numEntities++;
+                            if (visible) {
+                                parent.numVisibleEntities++;
+                                parent.checked = true;
+                            }
+                            parent = parent.parent;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    _withNodeTree(node, callback) {
+        callback(node);
+        const children = node.children;
+        if (!children) {
+            return;
+        }
+        for (let i = 0, len = children.length; i < len; i++) {
+            this._withNodeTree(children[i], callback);
+        }
+    }
+
+    _createTrees() {
+        if (this._rootNodes.length === 0) {
+            return;
+        }
+        const rootNodeElements = this._rootNodes.map((rootNode) => {
+            return this._createNodeElement(rootNode);
+        });
+        const ul = document.createElement('ul');
+        rootNodeElements.forEach((nodeElement) => {
+            ul.appendChild(nodeElement);
+        });
+        this._containerElement.appendChild(ul);
+        this._rootElement = ul;
+    }
+
+    _createNodeElement(node) {
+        const nodeElement = document.createElement('li');
+        //const nodeId = this._objectToNodeID(node.objectId);
+        const nodeId = node.nodeId;
+        nodeElement.id = 'node-' + nodeId;
+         //  ���ֻ��չ��Ч��
+        if (undefined != node.parent) {
+            if (node.children.length > 0) {
+                const switchElementId = "switch-" + nodeId;
+                const switchElement = document.createElement('a');
+                switchElement.href = '#';
+                switchElement.id = switchElementId;
+                switchElement.textContent = '+';
+                switchElement.classList.add('plus');
+                switchElement.addEventListener('click', this.switchExpandHandler);
+                nodeElement.appendChild(switchElement);
+            }
+        }else{
+            let switchElementId = "switch-" + nodeId;
+            let switchElement = document.createElement('a'); 
+           // switchElement.setAttribute('display', 'none');
+            switchElement.setAttribute('style', 'display: none');
+            switchElement.id = switchElementId; 
+            switchElement.addEventListener('click', this.switchExpandHandler);
+            nodeElement.appendChild(switchElement);
+        }
+ 
+  /*       if (node.children.length > 0) {
+            const switchElementId = "switch-" + nodeId;
+            const switchElement = document.createElement('a');
+            switchElement.href = '#';
+            switchElement.id = switchElementId;
+            switchElement.textContent = '+';
+            switchElement.classList.add('plus');
+            switchElement.addEventListener('click', this.switchExpandHandler);
+            nodeElement.appendChild(switchElement);
+        }   */
+        const labelbox = document.createElement('label');
+        const checkbox = document.createElement('input');
+        nodeElement.appendChild(labelbox);
+        checkbox.id = nodeId;
+        checkbox.type = "checkbox";
+        checkbox.checked = node.checked;
+        checkbox.style["pointer-events"] = "all";
+        checkbox.addEventListener("change", this._checkboxChangeHandler);
+        labelbox.appendChild(checkbox);
+        const span = document.createElement('span');
+        span.textContent = node.title;
+        nodeElement.appendChild(span);
+        span.oncontextmenu = (e) => {
+            this._treeViewPlugin.fire("contextmenu", {
+                event: e,
+                viewer: this._viewer,
+                treeViewPlugin: this._treeViewPlugin,
+                treeViewNode: node
+            });
+            e.preventDefault();
+        };
+        span.onclick = (e) => {
+            this._treeViewPlugin.fire("nodeTitleClicked", {
+                event: e,
+                viewer: this._viewer,
+                treeViewPlugin: this._treeViewPlugin,
+                treeViewNode: node
+            });
+            e.preventDefault();
+        };
+        return nodeElement;
+    }
+
+    /**
+     * @private
+     * @param depth
+     */
+    expandToDepth(depth) {
+        const expand = (node, countDepth) => {
+            if (countDepth === depth) {
+                return;
+            }
+            const nodeId = node.nodeId;
+            const switchElementId = "switch-" + nodeId;
+            const switchElement = document.getElementById(switchElementId);
+            if (switchElement) {
+                this._expandSwitchElement(switchElement);
+                const childNodes = node.children;
+                for (var i = 0, len = childNodes.length; i < len; i++) {
+                    const childNode = childNodes[i];
+                    expand(childNode, countDepth + 1);
+                }
+            }
+        };
+        for (let i = 0, len = this._rootNodes.length; i < len; i++) {
+            const rootNode = this._rootNodes[i];
+            expand(rootNode, 0);
+        }
+    }
+
+    /**
+     * @private
+     */
+    collapse() {
+        for (let i = 0, len = this._rootNodes.length; i < len; i++) {
+            const rootNode = this._rootNodes[i];
+            const objectId = rootNode.objectId;
+            this._collapseNode(objectId);
+        }
+    }
+
+    /**
+     * @private
+     * @param objectId
+     */
+    showNode(objectId) {
+        if (this._showListItemElementId) {
+            this.unShowNode();
+        }
+        const node = this._objectNodes[objectId];
+        if (!node) {
+            return; // Node may not exist for the given object if (this._pruneEmptyNodes == true)
+        }
+        const nodeId = node.nodeId;
+        const switchElementId = "switch-" + nodeId;
+        const switchElement = document.getElementById(switchElementId);
+        if (switchElement) {
+            this._expandSwitchElement(switchElement);
+            switchElement.scrollIntoView();
+            return;
+        }
+        const path = [];
+        path.unshift(node);
+        let parent = node.parent;
+        while (parent) {
+            path.unshift(parent);
+            parent = parent.parent;
+        }
+        for (let i = 0, len = path.length; i < len; i++) {
+            const node = path[i];
+            const nodeId = node.nodeId;
+            const switchElementId = "switch-" + nodeId;
+            const switchElement = document.getElementById(switchElementId);
+            if (switchElement) {
+                this._expandSwitchElement(switchElement);
+            }
+        }
+        const listItemElementId = 'node-' + nodeId;
+        const listItemElement = document.getElementById(listItemElementId);
+        listItemElement.scrollIntoView({block: "center"});
+        listItemElement.classList.add("highlighted-node");
+        this._showListItemElementId = listItemElementId;
+    }
+
+    /**
+     * @private
+     */
+    unShowNode() {
+        if (!this._showListItemElementId) {
+            return;
+        }
+        const listItemElement = document.getElementById(this._showListItemElementId);
+        if (!listItemElement) {
+            this._showListItemElementId = null;
+            return;
+        }
+        listItemElement.classList.remove("highlighted-node");
+        this._showListItemElementId = null;
+    }
+
+    _expandSwitchElement(switchElement) {
+        const parentElement = switchElement.parentElement;
+        const expanded = parentElement.getElementsByTagName('li')[0];
+        if (expanded) {
+            return;
+        }
+        const nodeId = parentElement.id.replace('node-', '');
+        const objectId = this._nodeToObjectID(nodeId);
+        const switchNode = this._objectNodes[objectId];
+        const childNodes = switchNode.children;
+        const nodeElements = childNodes.map((node) => {
+            return this._createNodeElement(node);
+        });
+        const ul = document.createElement('ul');
+        nodeElements.forEach((nodeElement) => {
+            ul.appendChild(nodeElement);
+        });
+        parentElement.appendChild(ul);
+         //  ���ֻ��չ��Ч��
+        if(undefined != switchNode.parent){
+            switchElement.classList.remove('plus');
+            switchElement.classList.add('minus');
+            switchElement.textContent = '-';
+            switchElement.removeEventListener('click', this.switchExpandHandler);
+            switchElement.addEventListener('click', this.switchCollapseHandler);
+        }else{ // ���㼶
+             
+        }
+        /* switchElement.classList.remove('plus');
+        switchElement.classList.add('minus');
+        switchElement.textContent = '-';
+        switchElement.removeEventListener('click', this.switchExpandHandler);
+        switchElement.addEventListener('click', this.switchCollapseHandler); */
+    }
+
+    _collapseNode(objectId) {
+        const nodeId = this._objectToNodeID(objectId);
+        const switchElementId = "switch-" + nodeId;
+        const switchElement = document.getElementById(switchElementId);
+        this._collapseSwitchElement(switchElement);
+    }
+
+    _collapseSwitchElement(switchElement) {
+        if (!switchElement) {
+            return;
+        }
+        const parent = switchElement.parentElement;
+        if (!parent) {
+            return;
+        }
+        const ul = parent.querySelector('ul');
+        if (!ul) {
+            return;
+        }
+        parent.removeChild(ul);
+        switchElement.classList.remove('minus');
+        switchElement.classList.add('plus');
+        switchElement.textContent = '+';
+        switchElement.removeEventListener('click', this.switchCollapseHandler);
+        switchElement.addEventListener('click', this.switchExpandHandler);
+    }
+
+    /**
+     * Destroys this ModelTreeView.
+     * @private
+     */
+    destroy() {
+        if (this._rootElement && !this._destroyed) {
+            this._rootElement.parentNode.removeChild(this._rootElement);
+            this._viewer.scene.off(this._onObjectVisibility);
+            this._destroyed = true;
+            idMap.removeItem(this._id);
+        }
+    }
+}
+
+export {ModelTreeView};