BIMviewer

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

3
/**
4
 * @private
5
 */
6
class ObjectContextMenu extends ContextMenu {
7

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

14
    _buildMenu(cfg) {
15

16
        const showObjectItems = [];
17
        const focusObjectItems = [];
18
        const measurementItems = [];
19

20
        const enableMeasurements = (!!cfg.enableMeasurements);
21

22
        if (this._bimViewer._enablePropertiesInspector) {
23
            showObjectItems.push(...[{
24
                getTitle: (context) => {
25
                    return context.viewer.localeService.translate("objectContextMenu.inspectProperties") || "Inspect Properties";
26
                },
27
                doAction: (context) => {
28
                    const objectId = context.entity.id;
29
                    context.bimViewer.showObjectProperties(objectId);
30
                }
31
            }]);
32
        }
33

34
        showObjectItems.push(...[
35
            {
36
                getTitle: (context) => {
37
                    return context.viewer.localeService.translate("objectContextMenu.showInTree") || "Show in Explorer";
38
                },
39
                doAction: (context) => {
40
                    const objectId = context.entity.id;
41
                    context.showObjectInExplorers(objectId);
42
                }
43
            }
44
        ]);
45

46
        focusObjectItems.push(...[
47
            {
48
                getTitle: (context) => {
49
                    return context.viewer.localeService.translate("objectContextMenu.viewFit") || "View Fit";
50
                },
51
                doAction: (context) => {
52
                    const viewer = context.viewer;
53
                    const scene = viewer.scene;
54
                    const entity = context.entity;
55
                    viewer.cameraFlight.flyTo({
56
                        aabb: entity.aabb,
57
                        duration: 0.5
58
                    }, () => {
59
                        setTimeout(function () {
60
                            scene.setObjectsHighlighted(scene.highlightedObjectIds, false);
61
                        }, 500);
62
                    });
63
                    viewer.cameraControl.pivotPos = math.getAABB3Center(entity.aabb);
64
                }
65
            },
66
            {
67
                getTitle: (context) => {
68
                    return context.viewer.localeService.translate("canvasContextMenu.viewFitSelection") || "View Fit Selected";
69
                },
70
                getEnabled: (context) => {
71
                    return (context.viewer.scene.numSelectedObjects > 0);
72
                },
73
                doAction: (context) => {
74
                    const viewer = context.viewer;
75
                    const scene = viewer.scene;
76
                    const sceneAABB = scene.getAABB(scene.selectedObjectIds);
77
                    viewer.cameraFlight.flyTo({
78
                        aabb: sceneAABB,
79
                        duration: 0.5
80
                    });
81
                    viewer.cameraControl.pivotPos = math.getAABB3Center(sceneAABB);
82
                }
83
            },
84
            {
85
                getTitle: (context) => {
86
                    return context.viewer.localeService.translate("objectContextMenu.viewFitAll") || "View Fit All";
87
                },
88
                doAction: (context) => {
89
                    const viewer = context.viewer;
90
                    const scene = viewer.scene;
91
                    const sceneAABB = scene.getAABB(scene.visibleObjectIds);
92
                    viewer.cameraFlight.flyTo({
93
                        aabb: sceneAABB,
94
                        duration: 0.5
95
                    });
96
                    viewer.cameraControl.pivotPos = math.getAABB3Center(sceneAABB);
97
                }
98
            }
99
        ]);
100

101
        if (enableMeasurements) {
102
            measurementItems.push(...[{
103
                getTitle: (context) => {
104
                    return context.viewer.localeService.translate("canvasContextMenu.measurements") || "Measurements";
105
                },
106
                doAction: function (context) {
107
                    // Does nothing
108
                },
109
                items: [ // Sub-menu
110
                    [{
111
                        getTitle: (context) => {
112
                            return context.viewer.localeService.translate("canvasContextMenu.clearMeasurements") || "Clear";
113
                        }, getEnabled: (context) => {
114
                            return (context.bimViewer.getNumMeasurements() > 0);
115
                        }, doAction: (context) => {
116
                            context.bimViewer.clearMeasurements();
117
                        }
118
                    }, {
119
                        getTitle: (context) => {
120
                            return context.bimViewer.getMeasurementsAxisVisible() ? context.viewer.localeService.translate("canvasContextMenu.hideMeasurementAxisWires") || "Hide Axis Wires" : context.viewer.localeService.translate("canvasContextMenu.showMeasurementAxisWires") || "Show Axis Wires"
121
                        }, getEnabled: (context) => {
122
                            return (context.bimViewer.getNumMeasurements() > 0);
123
                        }, doAction: (context) => {
124
                            context.bimViewer.setMeasurementsAxisVisible(!context.bimViewer.getMeasurementsAxisVisible());
125
                        }
126
                    }, {
127
                        getTitle: (context) => {
128
                            return context.bimViewer.getMeasurementsSnappingEnabled() ? context.viewer.localeService.translate("canvasContextMenu.disableMeasurementSnapping") || "Disable Snapping" : context.viewer.localeService.translate("canvasContextMenu.enableMeasurementSnapping") || "Enable Snapping"
129
                        }, getEnabled: (context) => {
130
                            return (context.bimViewer.getNumMeasurements() > 0);
131
                        }, doAction: (context) => {
132
                            context.bimViewer.setMeasurementsSnappingEnabled(!context.bimViewer.getMeasurementsSnappingEnabled());
133
                        }
134
                    }]]
135
            }]);
136
        }
137

138
        this.items = [
139
            showObjectItems,
140
            focusObjectItems,
141
            [
142
                {
143
                    getTitle: (context) => {
144
                        return context.viewer.localeService.translate("objectContextMenu.hide") || "Hide";
145
                    },
146
                    getEnabled: (context) => {
147
                        return context.entity.visible;
148
                    },
149
                    doAction: (context) => {
150
                        context.entity.visible = false;
151
                    }
152
                },
153
                {
154
                    getTitle: (context) => {
155
                        return context.viewer.localeService.translate("objectContextMenu.hideOthers") || "Hide Others";
156
                    },
157
                    doAction: (context) => {
158
                        const viewer = context.viewer;
159
                        const scene = viewer.scene;
160
                        const entity = context.entity;
161
                        const metaObject = viewer.metaScene.metaObjects[entity.id];
162
                        if (!metaObject) {
163
                            return;
164
                        }
165
                        scene.setObjectsVisible(scene.visibleObjectIds, false);
166
                        metaObject.withMetaObjectsInSubtree((metaObject) => {
167
                            const entity = scene.objects[metaObject.id];
168
                            if (entity) {
169
                                entity.visible = true;
170
                            }
171
                        });
172
                    }
173
                },
174
                {
175
                    getTitle: (context) => {
176
                        return context.viewer.localeService.translate("objectContextMenu.hideAll") || "Hide All";
177
                    },
178
                    getEnabled: (context) => {
179
                        return (context.viewer.scene.numVisibleObjects > 0);
180
                    },
181
                    doAction: (context) => {
182
                        context.viewer.scene.setObjectsVisible(context.viewer.scene.visibleObjectIds, false);
183
                    }
184
                },
185
                {
186
                    getTitle: (context) => {
187
                        return context.viewer.localeService.translate("objectContextMenu.showAll") || "Show All";
188
                    },
189
                    getEnabled: (context) => {
190
                        const scene = context.viewer.scene;
191
                        return ((scene.numVisibleObjects < scene.numObjects) || (context.viewer.scene.numXRayedObjects > 0));
192
                    },
193
                    doAction: (context) => {
194
                        const scene = context.viewer.scene;
195
                        scene.setObjectsVisible(scene.objectIds, true);
196
                        scene.setObjectsPickable(scene.xrayedObjectIds, true);
197
                        scene.setObjectsXRayed(scene.xrayedObjectIds, false);
198
                    }
199
                }
200
            ],
201
            [
202
                {
203
                    getTitle: (context) => {
204
                        return context.viewer.localeService.translate("objectContextMenu.xray") || "X-Ray";
205
                    },
206
                    getEnabled: (context) => {
207
                        return (!context.entity.xrayed);
208
                    },
209
                    doAction: (context) => {
210
                        const entity = context.entity;
211
                        entity.xrayed = true;
212
                        entity.pickable = context.bimViewer.getConfig("xrayPickable");
213
                    }
214
                },
215
                {
216
                    getTitle: (context) => {
217
                        return context.viewer.localeService.translate("objectContextMenu.xrayOthers") || "X-Ray Others";
218
                    },
219
                    doAction: (context) => {
220
                        const viewer = context.viewer;
221
                        const scene = viewer.scene;
222
                        const entity = context.entity;
223
                        const metaObject = viewer.metaScene.metaObjects[entity.id];
224
                        if (!metaObject) {
225
                            return;
226
                        }
227
                        scene.setObjectsVisible(scene.objectIds, true);
228
                        scene.setObjectsXRayed(scene.objectIds, true);
229
                        if (!context.bimViewer.getConfig("xrayPickable")) {
230
                            scene.setObjectsPickable(scene.objectIds, false);
231
                        }
232
                        metaObject.withMetaObjectsInSubtree((metaObject) => {
233
                            const entity = scene.objects[metaObject.id];
234
                            if (entity) {
235
                                entity.xrayed = false;
236
                                entity.pickable = true;
237
                            }
238
                        });
239
                    }
240
                },
241
                {
242
                    getTitle: (context) => {
243
                        return context.viewer.localeService.translate("objectContextMenu.xrayAll") || "X-Ray All";
244
                    },
245
                    getEnabled: (context) => {
246
                        const scene = context.viewer.scene;
247
                        return (scene.numXRayedObjects < scene.numObjects);
248
                    },
249
                    doAction: (context) => {
250
                        const scene = context.viewer.scene;
251
                        scene.setObjectsVisible(scene.objectIds, true);
252
                        if (!context.bimViewer.getConfig("xrayPickable")) {
253
                            scene.setObjectsPickable(scene.objectIds, false);
254
                        }
255
                        scene.setObjectsXRayed(scene.objectIds, true);
256
                    }
257
                },
258
                {
259
                    getTitle: (context) => {
260
                        return context.viewer.localeService.translate("objectContextMenu.xrayNone") || "X-Ray None";
261
                    },
262
                    getEnabled: (context) => {
263
                        return (context.viewer.scene.numXRayedObjects > 0);
264
                    },
265
                    doAction: (context) => {
266
                        const scene = context.viewer.scene;
267
                        const xrayedObjectIds = scene.xrayedObjectIds;
268
                        scene.setObjectsPickable(xrayedObjectIds, true);
269
                        scene.setObjectsXRayed(xrayedObjectIds, false);
270
                    }
271
                }
272
            ],
273
            [
274
                {
275
                    getTitle: (context) => {
276
                        return context.viewer.localeService.translate("objectContextMenu.select") || "Select";
277
                    },
278
                    getEnabled: (context) => {
279
                        return (!context.entity.selected);
280
                    },
281
                    doAction: (context) => {
282
                        context.entity.selected = true;
283

284
                    }
285
                },
286
                {
287
                    getTitle: (context) => {
288
                        return context.viewer.localeService.translate("objectContextMenu.undoSelect") || "Undo Select";
289
                    },
290
                    getEnabled: (context) => {
291
                        return context.entity.selected;
292
                    },
293
                    doAction: (context) => {
294
                        context.entity.selected = false;
295
                    }
296
                },
297
                {
298
                    getTitle: (context) => {
299
                        return context.viewer.localeService.translate("objectContextMenu.selectNone") || "Select None";
300
                    },
301
                    getEnabled: (context) => {
302
                        return (context.viewer.scene.numSelectedObjects > 0);
303
                    },
304
                    doAction: (context) => {
305
                        context.viewer.scene.setObjectsSelected(context.viewer.scene.selectedObjectIds, false);
306
                    }
307
                }
308
            ],
309
            [
310
                {
311
                    getTitle: (context) => {
312
                        return context.viewer.localeService.translate("objectContextMenu.clearSlices") || "Clear Slices";
313
                    },
314
                    getEnabled: (context) => {
315
                        return (context.bimViewer.getNumSections() > 0);
316
                    },
317
                    doAction: (context) => {
318
                        context.bimViewer.clearSections();
319
                    }
320
                }
321
            ],
322
            measurementItems
323
        ];
324
    }
325
}
326

327
export {ObjectContextMenu};