BIMviewer

1
import {ContextMenu, math} from "@xeokit/xeokit-sdk/dist/xeokit-sdk.es.js";
2

3
const tempVec3 = math.vec3();
4

5
/**
6
 * @private
7
 */
8
class TreeViewContextMenu extends ContextMenu {
9

10
    constructor(bimViewer, cfg = {}) {
11
        super(cfg);
12
        this._bimViewer = bimViewer;
13
        this._buildMenu(cfg);
14
    }
15

16
    _buildMenu(cfg) {
17

18
        const showObjectItems = [];
19
        const focusObjectItems = [];
20
        const measurementItems = [];
21

22
        const enableMeasurements = (!!cfg.enableMeasurements);
23

24
        if (this._bimViewer._enablePropertiesInspector) {
25
            showObjectItems.push({
26
                getTitle: (context) => {
27
                    return context.viewer.localeService.translate("treeViewContextMenu.inspectProperties") || "Inspect Properties";
28
                }, getShown(context) {
29
                    return !!context.viewer.metaScene.metaObjects[context.treeViewNode.objectId];
30
                }, doAction: (context) => {
31
                    const objectId = context.treeViewNode.objectId;
32
                    context.bimViewer.showObjectProperties(objectId);
33
                }
34
            });
35
        }
36

37
        focusObjectItems.push(...[{
38
            getTitle: (context) => {
39
                return context.viewer.localeService.translate("treeViewContextMenu.viewFit") || "View Fit";
40
            }, doAction: function (context) {
41
                const viewer = context.viewer;
42
                const scene = viewer.scene;
43
                const objectIds = [];
44
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
45
                    if (treeViewNode.objectId) {
46
                        objectIds.push(treeViewNode.objectId);
47
                    }
48
                });
49
                scene.setObjectsVisible(objectIds, true);
50
                scene.setObjectsHighlighted(objectIds, true);
51
                const aabb = scene.getAABB(objectIds);
52
                viewer.cameraFlight.flyTo({
53
                    aabb: aabb, duration: 0.5
54
                }, () => {
55
                    setTimeout(function () {
56
                        scene.setObjectsHighlighted(scene.highlightedObjectIds, false);
57
                    }, 500);
58
                });
59
                viewer.cameraControl.pivotPos = math.getAABB3Center(aabb);
60
            }
61
        }, {
62
            getTitle: (context) => {
63
                return context.viewer.localeService.translate("canvasContextMenu.viewFitSelection") || "View Fit Selected";
64
            }, getEnabled: (context) => {
65
                return (context.viewer.scene.numSelectedObjects > 0);
66
            }, doAction: (context) => {
67
                const viewer = context.viewer;
68
                const scene = viewer.scene;
69
                const sceneAABB = scene.getAABB(scene.selectedObjectIds);
70
                viewer.cameraFlight.flyTo({
71
                    aabb: sceneAABB, duration: 0.5
72
                });
73
                viewer.cameraControl.pivotPos = math.getAABB3Center(sceneAABB);
74
            }
75
        }, {
76
            getTitle: (context) => {
77
                return context.viewer.localeService.translate("treeViewContextMenu.viewFitAll") || "View Fit All";
78
            }, doAction: function (context) {
79
                const viewer = context.viewer;
80
                const scene = viewer.scene;
81
                const sceneAABB = scene.getAABB(scene.visibleObjectIds);
82
                viewer.cameraFlight.flyTo({
83
                    aabb: sceneAABB, duration: 0.5
84
                });
85
                viewer.cameraControl.pivotPos = math.getAABB3Center(sceneAABB);
86
            }
87
        }]);
88

89
        if (enableMeasurements) {
90
            measurementItems.push(...[{
91
                getTitle: (context) => {
92
                    return context.viewer.localeService.translate("canvasContextMenu.measurements") || "Measurements";
93
                },
94
                doAction: function (context) {
95
                    // Does nothing
96
                },
97
                items: [ // Sub-menu
98
                    [{
99
                        getTitle: (context) => {
100
                            return context.viewer.localeService.translate("canvasContextMenu.clearMeasurements") || "Clear";
101
                        }, getEnabled: (context) => {
102
                            return (context.bimViewer.getNumMeasurements() > 0);
103
                        }, doAction: (context) => {
104
                            context.bimViewer.clearMeasurements();
105
                        }
106
                    }, {
107
                        getTitle: (context) => {
108
                            return context.bimViewer.getMeasurementsAxisVisible() ? context.viewer.localeService.translate("canvasContextMenu.hideMeasurementAxisWires") || "Hide Axis Wires" : context.viewer.localeService.translate("canvasContextMenu.showMeasurementAxisWires") || "Show Axis Wires"
109
                        }, getEnabled: (context) => {
110
                            return (context.bimViewer.getNumMeasurements() > 0);
111
                        }, doAction: (context) => {
112
                            context.bimViewer.setMeasurementsAxisVisible(!context.bimViewer.getMeasurementsAxisVisible());
113
                        }
114
                    }, {
115
                        getTitle: (context) => {
116
                            return context.bimViewer.getMeasurementsSnappingEnabled() ? context.viewer.localeService.translate("canvasContextMenu.disableMeasurementSnapping") || "Disable Snapping" : context.viewer.localeService.translate("canvasContextMenu.enableMeasurementSnapping") || "Enable Snapping"
117
                        }, getEnabled: (context) => {
118
                            return (context.bimViewer.getNumMeasurements() > 0);
119
                        }, doAction: (context) => {
120
                            context.bimViewer.setMeasurementsSnappingEnabled(!context.bimViewer.getMeasurementsSnappingEnabled());
121
                        }
122
                    }]]
123
            }]);
124
        }
125

126
        this.items = [showObjectItems, focusObjectItems, [{
127
            getTitle: (context) => {
128
                return context.viewer.localeService.translate("treeViewContextMenu.isolate") || "Isolate";
129
            }, doAction: function (context) {
130
                const viewer = context.viewer;
131
                const scene = viewer.scene;
132
                const objectIds = [];
133
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
134
                    if (treeViewNode.objectId) {
135
                        objectIds.push(treeViewNode.objectId);
136
                    }
137
                });
138
                const aabb = scene.getAABB(objectIds);
139

140
                viewer.cameraControl.pivotPos = math.getAABB3Center(aabb, tempVec3);
141

142
                scene.setObjectsXRayed(scene.xrayedObjectIds, false);
143
                scene.setObjectsVisible(scene.visibleObjectIds, false);
144
                // scene.setObjectsPickable(scene.objectIds, false);
145
                scene.setObjectsSelected(scene.selectedObjectIds, false);
146

147
                scene.setObjectsVisible(objectIds, true);
148
                // scene.setObjectsPickable(objectIds, true);
149

150
                viewer.cameraFlight.flyTo({
151
                    aabb: aabb
152
                }, () => {
153
                });
154
            }
155
        }], [{
156
            getTitle: (context) => {
157
                return context.viewer.localeService.translate("treeViewContextMenu.hide") || "Hide";
158
            }, doAction: function (context) {
159
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
160
                    if (treeViewNode.objectId) {
161
                        const entity = context.viewer.scene.objects[treeViewNode.objectId];
162
                        if (entity) {
163
                            entity.visible = false;
164
                        }
165
                    }
166
                });
167
            }
168
        }, {
169
            getTitle: (context) => {
170
                return context.viewer.localeService.translate("treeViewContextMenu.hideOthers") || "Hide Others";
171
            }, doAction: function (context) {
172
                const scene = context.viewer.scene;
173
                scene.setObjectsVisible(scene.visibleObjectIds, false);
174
                scene.setObjectsPickable(scene.xrayedObjectIds, true);
175
                scene.setObjectsXRayed(scene.xrayedObjectIds, false);
176
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
177
                    if (treeViewNode.objectId) {
178
                        const entity = scene.objects[treeViewNode.objectId];
179
                        if (entity) {
180
                            entity.visible = true;
181
                        }
182
                    }
183
                });
184
            }
185
        }, {
186
            getTitle: (context) => {
187
                return context.viewer.localeService.translate("treeViewContextMenu.hideAll") || "Hide All";
188
            }, getEnabled: function (context) {
189
                return (context.viewer.scene.visibleObjectIds.length > 0);
190
            }, doAction: function (context) {
191
                context.viewer.scene.setObjectsVisible(context.viewer.scene.visibleObjectIds, false);
192
            }
193
        }], [{
194
            getTitle: (context) => {
195
                return context.viewer.localeService.translate("treeViewContextMenu.show") || "Show";
196
            }, doAction: function (context) {
197
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
198
                    if (treeViewNode.objectId) {
199
                        const entity = context.viewer.scene.objects[treeViewNode.objectId];
200
                        if (entity) {
201
                            entity.visible = true;
202
                            if (entity.xrayed) {
203
                                entity.pickable = true;
204
                            }
205
                            entity.xrayed = false;
206
                            entity.selected = false;
207
                        }
208
                    }
209
                });
210
            }
211
        }, {
212
            getTitle: (context) => {
213
                return context.viewer.localeService.translate("treeViewContextMenu.showOthers") || "Shows Others";
214
            }, doAction: function (context) {
215
                const scene = context.viewer.scene;
216
                scene.setObjectsVisible(scene.objectIds, true);
217
                scene.setObjectsPickable(scene.xrayedObjectIds, true);
218
                scene.setObjectsXRayed(scene.xrayedObjectIds, false);
219
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
220
                    if (treeViewNode.objectId) {
221
                        const entity = scene.objects[treeViewNode.objectId];
222
                        if (entity) {
223
                            entity.visible = false;
224
                        }
225
                    }
226
                });
227
            }
228
        }, {
229
            getTitle: (context) => {
230
                return context.viewer.localeService.translate("treeViewContextMenu.showAll") || "Show All";
231
            }, getEnabled: function (context) {
232
                const scene = context.viewer.scene;
233
                return ((scene.numVisibleObjects < scene.numObjects) || (context.viewer.scene.numXRayedObjects > 0));
234
            }, doAction: function (context) {
235
                const scene = context.viewer.scene;
236
                scene.setObjectsVisible(scene.objectIds, true);
237
                scene.setObjectsPickable(scene.xrayedObjectIds, true);
238
                scene.setObjectsXRayed(scene.xrayedObjectIds, false);
239
            }
240
        }], [{
241
            getTitle: (context) => {
242
                return context.viewer.localeService.translate("treeViewContextMenu.xray") || "X-Ray";
243
            }, doAction: function (context) {
244
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
245
                    if (treeViewNode.objectId) {
246
                        const entity = context.viewer.scene.objects[treeViewNode.objectId];
247
                        if (entity) {
248
                            entity.selected = false;
249
                            entity.xrayed = true;
250
                            entity.visible = true;
251
                            entity.pickable = context.bimViewer.getConfig("xrayPickable");
252
                        }
253
                    }
254
                });
255
            }
256
        }, {
257
            getTitle: (context) => {
258
                return context.viewer.localeService.translate("treeViewContextMenu.undoXray") || "Undo X-Ray";
259
            }, doAction: function (context) {
260
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
261
                    if (treeViewNode.objectId) {
262
                        const entity = context.viewer.scene.objects[treeViewNode.objectId];
263
                        if (entity) {
264
                            entity.xrayed = false;
265
                            entity.pickable = true;
266
                        }
267
                    }
268
                });
269
            }
270
        }, {
271
            getTitle: (context) => {
272
                return context.viewer.localeService.translate("treeViewContextMenu.xrayOthers") || "X-Ray Others";
273
            }, doAction: function (context) {
274
                const scene = context.viewer.scene;
275
                scene.setObjectsVisible(scene.objectIds, true);
276
                if (!context.bimViewer.getConfig("xrayPickable")) {
277
                    scene.setObjectsPickable(scene.objectIds, false);
278
                }
279
                scene.setObjectsXRayed(scene.objectIds, true);
280
                scene.setObjectsSelected(scene.selectedObjectIds, false);
281
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
282
                    if (treeViewNode.objectId) {
283
                        const entity = scene.objects[treeViewNode.objectId];
284
                        if (entity) {
285
                            entity.xrayed = false;
286
                            entity.pickable = true;
287
                        }
288
                    }
289
                });
290
            }
291
        }, {
292
            getTitle: (context) => {
293
                return context.viewer.localeService.translate("treeViewContextMenu.xrayAll") || "X-Ray All";
294
            }, doAction: function (context) {
295
                const scene = context.viewer.scene;
296
                scene.setObjectsVisible(scene.objectIds, true);
297
                scene.setObjectsXRayed(scene.objectIds, true);
298
                scene.setObjectsSelected(scene.selectedObjectIds, false);
299
                scene.setObjectsPickable(scene.objectIds, false);
300
            }
301
        }, {
302
            getTitle: (context) => {
303
                return context.viewer.localeService.translate("treeViewContextMenu.xrayNone") || "X-Ray None";
304
            }, getEnabled: function (context) {
305
                return (context.viewer.scene.numXRayedObjects > 0);
306
            }, doAction: function (context) {
307
                const scene = context.viewer.scene;
308
                const xrayedObjectIds = scene.xrayedObjectIds;
309
                scene.setObjectsPickable(xrayedObjectIds, true);
310
                scene.setObjectsXRayed(xrayedObjectIds, false);
311
            }
312
        }], [{
313
            getTitle: (context) => {
314
                return context.viewer.localeService.translate("treeViewContextMenu.select") || "Select";
315
            }, doAction: function (context) {
316
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
317
                    if (treeViewNode.objectId) {
318
                        const entity = context.viewer.scene.objects[treeViewNode.objectId];
319
                        if (entity) {
320
                            entity.selected = true;
321
                            entity.visible = true;
322
                        }
323
                    }
324
                });
325
            }
326
        }, {
327
            getTitle: (context) => {
328
                return context.viewer.localeService.translate("treeViewContextMenu.undoSelect") || "Undo Select";
329
            }, doAction: function (context) {
330
                context.treeViewPlugin.withNodeTree(context.treeViewNode, (treeViewNode) => {
331
                    if (treeViewNode.objectId) {
332
                        const entity = context.viewer.scene.objects[treeViewNode.objectId];
333
                        if (entity) {
334
                            entity.selected = false;
335
                        }
336
                    }
337
                });
338
            }
339
        }, {
340
            getTitle: (context) => {
341
                return context.viewer.localeService.translate("treeViewContextMenu.selectNone") || "Select None";
342
            }, getEnabled: function (context) {
343
                return (context.viewer.scene.numSelectedObjects > 0);
344
            }, doAction: function (context) {
345
                context.viewer.scene.setObjectsSelected(context.viewer.scene.selectedObjectIds, false);
346
            }
347
        }], [{
348
            getTitle: (context) => {
349
                return context.viewer.localeService.translate("treeViewContextMenu.clearSlices") || "Clear Slices";
350
            }, getEnabled: function (context) {
351
                return (context.bimViewer.getNumSections() > 0);
352
            }, doAction: function (context) {
353
                context.bimViewer.clearSections();
354
            }
355
        }],
356
            measurementItems];
357
    }
358
}
359

360
export {TreeViewContextMenu};