@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/threedselector/threedselector/threedselector.component.js

@@ -0,0 +1,1116 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { Color, Euler, Light, Mesh, PlaneGeometry, Shape, ShapeGeometry, Vector2, Vector3 } from 'three';
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import { IconName } from '../../../core/enum/icon-name.enum';
+import { ElementToolbarComponent } from '../element-toolbar/element-toolbar.component';
+import { CustomButton } from '../../../core/model/custom-button';
+import { WallItem } from '../../core3d/items/wall-objects';
+import { isItemGroupType, isWallItemGroupType, itemTypeFromPlacement } from '../../core3d/items/factory';
+import { ItemGroup } from '../../core3d/items/item-group';
+import { CustomFloorGroupResult } from '../../core3d/model/custom-floor-group-result';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { WallItemGroup } from '../../core3d/items/wall-objects';
+import { ObjectUtils } from '../../../core/utils/object.utils';
+import { ModelDialogComponent } from '../../../shared/model-dialog/model-dialog.component';
+import { IconEnum } from '../../../core/enum/icon.enum';
+import { DialogType } from '../../../shared/dialog/enum/dialog-type.enum';
+import { ErrorMessage } from '../../../core/model/error-message';
+import { ResultType } from '../../core3d/enum/result-type.enum';
+import { CustomMesh } from '../../core3d/items/custom-objects';
+import { Toast } from '../../../core/model/toast';
+import { isNill } from '../../../core/utils/function/is-nill.function';
+import { CustomWallFloorItem } from '../../core3d/items/custom-wall-floor-item';
+import { CustomWallItem } from '../../core3d/items/custom-wall-item';
+import { GoogleTagManagerEvent } from '../../../core/enum/google-tag-manager-event.enum';
+import { CameraSettingsDialogComponent } from '../../../shared/camera-settings-dialog/camera-settings-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../shared/screen-size-analysis/screen-size-analysis.service";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../../../core/service/homedecorator-app.service";
+import * as i4 from "../../../core/service/homedecorator-connector.service";
+import * as i5 from "../../../core/service/message-bus.service";
+import * as i6 from "./service/load-furniture.service";
+import * as i7 from "./service/build-furniture.service";
+import * as i8 from "../../../core/service/integration.service";
+import * as i9 from "../../../core/service/homedecorator-dictionary.service";
+import * as i10 from "../../../core/service/toast.service";
+import * as i11 from "../../core3d/service/scene.service";
+import * as i12 from "../../../shared/dialog/service/dialog.service";
+import * as i13 from "../../core3d/service/camera.service";
+import * as i14 from "../../../core/service/presets.service";
+import * as i15 from "../../core3d/service/item.service";
+import * as i16 from "../../../core/service/homedecorator-settings.service";
+import * as i17 from "../../core3d/service/scene-options.service";
+import * as i18 from "./service/dimensions.service";
+import * as i19 from "../../../core/service/homedecorator-app-event.service";
+import * as i20 from "../../room-planner/components/floorplanner/service/floorplan.service";
+import * as i21 from "../../core3d/service/floor.service";
+import * as i22 from "../../../core/service/homedecorator-icon-cache.service";
+import * as i23 from "../../core3d/service/ar.service";
+import * as i24 from "../../../service/google-tag-manager.service";
+import * as i25 from "../../../core/service/error.service";
+import * as i26 from "../../core3d/service/rotation.service";
+import * as i27 from "../../room-planner/components/floorplanner/service/room.service";
+import * as i28 from "../../../core/service/app-state.service";
+import * as i29 from "../../../core/service/progress.service";
+import * as i30 from "./service/animation.service";
+import * as i31 from "./service/resize.service";
+import * as i32 from "../../lite-selector/lite-selector/service/customizer.service";
+import * as i33 from "../../../core/service/dynamic-camera.service";
+import * as i34 from "../../threed-in-photo/services/threed-in-photo-initializer.service";
+import * as i35 from "../../render/service/render.service";
+import * as i36 from "../../render/service/new-render.service";
+import * as i37 from "../../../core/service/homedecorator-connector-adapter.service";
+import * as i38 from "../../lite-selector/lite-selector/lite-selector.component";
+import * as i39 from "../element-toolbar/element-toolbar.component";
+import * as i40 from "../element-buttons/element-buttons.component";
+import * as i41 from "../../../shared/toolbar-icon/toolbar-icon.component";
+import * as i42 from "../../lite-selector/lite-selector/component/animation/animation.component";
+import * as i43 from "../../lite-selector/lite-selector/component/customizer/customizer.component";
+import * as i44 from "../element-slider/element-slider.component";
+import * as i45 from "@angular/common";
+import * as i46 from "../../../core/pipe/localize.pipe";
+export class ThreedselectorComponent {
+    constructor(screenSizeService, _dialog, _appService, _iOne, _messageBus, _loadFurnitureService, _buildFurnitureService, _integrationService, _dictionaryService, _toastService, _messageService, _sceneService, _dialogService, _cameraService, _presetsService, _itemService, _settingsService, _sceneOptionsService, _dimensionsService, _appEventService, _floorplanService, _floorService, _iconCacheService, _arService, _googleTagManager, _errorService, _rotationService, _roomService, _appStateService, _progressService, _animationService, _resizeService, _customizerService, _dynamicCameraService, _threedInPhotoInitializerService, _renderService, _newRenderService, _connectorAdapterService) {
+        this.screenSizeService = screenSizeService;
+        this._dialog = _dialog;
+        this._appService = _appService;
+        this._iOne = _iOne;
+        this._messageBus = _messageBus;
+        this._loadFurnitureService = _loadFurnitureService;
+        this._buildFurnitureService = _buildFurnitureService;
+        this._integrationService = _integrationService;
+        this._dictionaryService = _dictionaryService;
+        this._toastService = _toastService;
+        this._messageService = _messageService;
+        this._sceneService = _sceneService;
+        this._dialogService = _dialogService;
+        this._cameraService = _cameraService;
+        this._presetsService = _presetsService;
+        this._itemService = _itemService;
+        this._settingsService = _settingsService;
+        this._sceneOptionsService = _sceneOptionsService;
+        this._dimensionsService = _dimensionsService;
+        this._appEventService = _appEventService;
+        this._floorplanService = _floorplanService;
+        this._floorService = _floorService;
+        this._iconCacheService = _iconCacheService;
+        this._arService = _arService;
+        this._googleTagManager = _googleTagManager;
+        this._errorService = _errorService;
+        this._rotationService = _rotationService;
+        this._roomService = _roomService;
+        this._appStateService = _appStateService;
+        this._progressService = _progressService;
+        this._animationService = _animationService;
+        this._resizeService = _resizeService;
+        this._customizerService = _customizerService;
+        this._dynamicCameraService = _dynamicCameraService;
+        this._threedInPhotoInitializerService = _threedInPhotoInitializerService;
+        this._renderService = _renderService;
+        this._newRenderService = _newRenderService;
+        this._connectorAdapterService = _connectorAdapterService;
+        this.iconName = IconName;
+        this.customizeButtonClicked = new EventEmitter();
+        this.selections = [];
+        this.editElementMenu = [];
+        this.editAddButtons = [];
+        this.editCustomizeButton = [];
+        this.resizeButtons = [];
+        this.selectedElementPosition = new Vector2();
+        this.showElementToolbar = false;
+        this.showLiteSelector = false;
+        this.showSelections = false;
+        this.showAnswers = false;
+        this.showCustomizeButtons = false;
+        this.showSwapButton = true;
+        this.standAlone = false;
+        this.shouldShowLabel = false;
+        this._skuAlreadySet = false;
+        this._itemsFromScratch = [];
+        this._itemsNeedUserInput = [];
+        this._subs = [];
+        this._loadingFromPreset = false;
+        this._presetsService.register(this);
+    }
+    ngOnInit() {
+        this._subs.push(this._appEventService.answerCountReceived.subscribe((answerCount) => this._handleAnswerCountReceived(answerCount)), this._messageBus.subscribe(MessageType.LoadIOneFurnitureIntoSceneBySKU, ({ sku, settings, position }) => this._handleLoadIOneFurnitureIntoSceneBySKU(sku, settings, position)), this._messageBus.subscribe(MessageType.CopyIOneFurnitureIntoSceneBySKU, (original) => this._handleCopyIOneFurnitureIntoSceneBySKU(original)), this._buildFurnitureService.configureModeChanged.subscribe(configuringModeChange => this._handleConfigureModeChange(configuringModeChange)), this._buildFurnitureService.toggleSelectedElement.subscribe((element) => this._selectedElementToggle(element)), this._buildFurnitureService.buildFinished.subscribe((result) => this._handleBuildFinished(result)), this._buildFurnitureService.answerSelected.subscribe((result) => this._answerSelected(result)), this._sceneService.onAfterRender.subscribe(() => this._handleRender()), this._appService.skuSet.subscribe(sku => this._handleSkuSet(sku)), this._appEventService.articleInfoReceived.subscribe(info => this._handleInfoClick(info)), this._messageService.subscribe(MessageType.UndefinedErrorOccured, () => this._handleUndefinedErrorOccured()), this._presetsService.afterLoad.subscribe(() => this._afterLoadFromPreset()), this._messageBus.subscribe(MessageType.Undo, () => this._clearItems()), this._messageBus.subscribe(MessageType.Redo, () => this._clearItems()), this._messageBus.subscribe(MessageType.StartWithEmptyRoom, () => this._clearItems()), this._messageBus.subscribe(MessageType.StartWithPreset, () => this._clearItems()), this._messageBus.subscribe(MessageType.LoadRoomFromPreset, () => this._clearItems()), this._messageBus.subscribe(MessageType.LoadRoomFromCloud, () => this._clearItems()), this._messageBus.subscribe(MessageType.NewRoom, () => this._clearItems()), this._messageBus.subscribe(MessageType.ResetRoomplan, () => this._clearItems()), this._messageBus.subscribe(MessageType.LoadScaledDiagram, () => this._clearItems()), this._presetsService.beforeLoad.subscribe(() => this._clearItems()), this._messageService.subscribe(MessageType.ItemSelected, (item) => this.objectSelected(item)), this._messageService.subscribe(MessageType.ItemUnselected, () => this._removeButtons()), this.screenSizeService.screenSizeChanged.subscribe((info) => {
+            this.shouldShowLabel = info.isPhoneSize;
+        }), this._settingsService.settingsLoaded.subscribe((loaded) => {
+            if (loaded) {
+                this.showSwapButton = !this._settingsService.settings.options.instantReplace;
+            }
+        }));
+        this._addModelDialogToolbar();
+    }
+    ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+    }
+    copySceneInstance(saveAs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ( /*!this._settingsService.isPrivate && */saveAs) {
+                const furniture = this._itemService.getIOneFurniture();
+                return this._handleCopyInstanceForFurniture(furniture);
+            }
+            else {
+                return Promise.resolve();
+            }
+        });
+    }
+    loadObjects({ furniture }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!furniture) {
+                return null;
+            }
+            this._loadingFromPreset = true;
+            const iONEObjectsToLoad = furniture.filter(o => this._isIONEObject(o));
+            furniture
+                .filter((o) => isItemGroupType(o.item_type))
+                .forEach(g => {
+                let groupAdded = false;
+                const itemGroup = isWallItemGroupType(g.item_type) ? new WallItemGroup() : new ItemGroup();
+                itemGroup.locked = g.locked;
+                itemGroup.position.set(g.xpos, g.ypos, g.zpos);
+                itemGroup.rotation.set(0, g.rotation, 0);
+                const children = g.children;
+                children.forEach(ch => {
+                    if (this._isIONEObject(ch)) {
+                        if (!groupAdded) {
+                            this._itemService.addItem(itemGroup);
+                            groupAdded = true;
+                        }
+                        ch.itemGroup = itemGroup;
+                        iONEObjectsToLoad.push(ch);
+                    }
+                });
+            });
+            return this._handleLoadIOneFurnitureFromPreset(iONEObjectsToLoad);
+        });
+    }
+    getObjects() {
+        // return {furniture: this.threeService.model.saveFurniture()};
+    }
+    objectSelected(object) {
+        this._removeCustomButtons();
+        this.showCustomizeButtons = true;
+        this.selectedObject = object;
+        object.traverse((child) => {
+            const customizeButton = child.name && child.name.toLowerCase().startsWith('p_');
+            if (customizeButton) {
+                this.selectionToCustomize = child.parent;
+                this.editCustomizeButton.push(new CustomButton('', () => {
+                    this.handleCustomizeClick();
+                }, this.selectionToCustomize));
+            }
+        });
+        this._handleRender();
+    }
+    handleCustomizeClick() {
+        this._customizerService.selectedObject = this.selectionToCustomize;
+        this._messageService.emit(MessageType.SetLeftSidebar, this.selectedThreedObjectCustomizationSidebar);
+    }
+    swapElement() {
+        if (this._selectedElementObject) {
+            this._buildFurnitureService.replaceSelection(ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject), this.activeMetadata);
+            if (!this._settingsService.settings.options.instantReplace) {
+                this._resetSelectedElement();
+            }
+        }
+    }
+    deleteElement() {
+        if (this._selectedElementObject) {
+            this._buildFurnitureService.deleteSelection(ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject), this.activeMetadata);
+            this._resetSelectedElement();
+        }
+    }
+    cancelElementReplace(rebuild = false) {
+        this._buildFurnitureService.cancelAnswer(this.activeMetadata, false, true);
+        this._resetSelectedElement();
+    }
+    openAnimationSidebar() {
+        this._messageService.emit(MessageType.SetLeftSidebar, this.selectedThreedObjectAnimationSidebar);
+    }
+    handleShowChangeSelector(show) {
+        if (!show) {
+            if (this.showAnswers) {
+                this._buildFurnitureService.cancelAnswer(this.activeMetadata);
+            }
+            this._buildFurnitureService.cancelConfiguringCurrentInstance();
+        }
+    }
+    setModelErrorDialog() {
+        this._dialog.open(ModelDialogComponent);
+    }
+    _clearItems() {
+        this._itemsFromScratch.length = 0;
+    }
+    _handleSkuSet(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (sku) {
+                this._subs.push(this._iOne.controllerInitialized.subscribe((initialized) => __awaiter(this, void 0, void 0, function* () {
+                    if (initialized) {
+                        this._prepareStandaloneConfigurator(sku);
+                    }
+                })), this._appService.floorTexturesLoaded.subscribe(textures => this._handleFloorsLoaded(textures)));
+                const arButton = {
+                    id: 2,
+                    elementId: 'standalone_ar_session',
+                    tooltip: 'START_AR_SESSION',
+                    order: 10,
+                    image: this._iconCacheService.getIconAsBase64(IconEnum.ArCircle),
+                    toggle: false,
+                    show: (yield this._arService.arSupported()) &&
+                        this._settingsService.settings.options.showStandaloneARButton &&
+                        this._settingsService.settings.options.arEnabled,
+                    click: () => {
+                        const object = this._itemService.getConfigurables()[0] /*.cloneVisible()*/;
+                        if (object) {
+                            this._sceneService.arMode = true;
+                            this._sceneService.addObject(object);
+                        }
+                    }
+                };
+                this._sceneOptionsService.addSceneOptionButton(arButton);
+            }
+        });
+    }
+    _handleFloorsLoaded(textures) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (textures) {
+                let defaultFloor;
+                if (this._settingsService.settings.options.useStandaloneFloors) {
+                    this._standaloneFloors = this._appService.getFloorsStandalone();
+                    defaultFloor = this._standaloneFloors.find(f => f.defaultStandalone);
+                }
+                let floorGeometry;
+                if (defaultFloor && defaultFloor.simplePlane) {
+                    floorGeometry = new PlaneGeometry(6, 6);
+                }
+                else {
+                    const corners = [
+                        this._floorplanService.newCorner(-3, 3),
+                        this._floorplanService.newCorner(-3, -3),
+                        this._floorplanService.newCorner(3, -3),
+                        this._floorplanService.newCorner(3, 3),
+                    ];
+                    const points = corners.map(corner => new Vector2(corner.x, corner.y));
+                    const shape = new Shape(points);
+                    floorGeometry = new ShapeGeometry(shape).center();
+                }
+                yield this._floorService.generateFloorPlane('white', defaultFloor, undefined, undefined, floorGeometry);
+                this._floorService.getFloorPlane().visible = this._settingsService.settings.options.useStandaloneFloors;
+                this._sceneService.scene.background = new Color(parseInt(this._settingsService.settings.standaloneSceneBackgroundColor, 0));
+                this._sceneService.needsRender = true;
+                if (this._standaloneFloors && this._standaloneFloors.length > 1) {
+                    this._upsertFloorButtons(defaultFloor);
+                }
+            }
+        });
+    }
+    _upsertFloorButtons(activeFloor) {
+        const floorButtons = [];
+        let newFloorButton;
+        this._standaloneFloors.forEach((f, index) => {
+            if (f !== activeFloor) {
+                newFloorButton = {
+                    id: index,
+                    elementId: `standalone_floor_${f.name}`,
+                    tooltip: f.name,
+                    class: 'circle',
+                    show: false,
+                    object: f,
+                    image: this._settingsService.settings.assetPath + f.url,
+                    click: (floor) => this._changeStandaloneFloor(floor)
+                };
+                floorButtons.push(newFloorButton);
+            }
+        });
+        const activeFloorButton = {
+            id: 10,
+            elementId: 'standalone_change_floor',
+            tooltip: 'CHANGE_FLOOR',
+            order: 8,
+            class: 'circle',
+            object: activeFloor,
+            children: floorButtons,
+            show: true,
+            image: this._settingsService.settings.assetPath + activeFloor.url
+        };
+        this._sceneOptionsService.updateSceneOptionButton(activeFloorButton);
+    }
+    _changeStandaloneFloor(floor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._floorService.setFloorTexture(null, floor);
+            this._upsertFloorButtons(floor);
+            this._sceneService.updatePathTracer();
+        });
+    }
+    _createDownloadButton() {
+        const download3DModelButton = {
+            id: 100,
+            elementId: 'standalone_download_model',
+            tooltip: 'DOWNLOAD_MODEL',
+            order: 2,
+            class: 'circle',
+            label: 'cloud_download',
+            show: true,
+            click: () => this._buildFurnitureService.downloadCurrentCustomFloorgroup()
+        };
+        this._sceneOptionsService.updateSceneOptionButton(download3DModelButton);
+    }
+    _createCameraSettingsButton() {
+        const cameraSettingsButton = {
+            id: 110,
+            elementId: 'standalone_camera_settings',
+            tooltip: 'CAMERA_SETTINGS',
+            order: 1,
+            class: 'circle',
+            label: 'camera_settings',
+            show: true,
+            click: () => this._openCameraSettingsDialog()
+        };
+        this._sceneOptionsService.updateSceneOptionButton(cameraSettingsButton);
+    }
+    _openCameraSettingsDialog() {
+        this._dialog.open(CameraSettingsDialogComponent, {
+            width: '600px'
+        });
+    }
+    _createMeasurementsButton() {
+        const button = {
+            id: 1,
+            elementId: 'standalone_show_measurements',
+            tooltip: 'SHOW_MEASUREMENTS',
+            order: 11,
+            image: this._iconCacheService.getIconAsBase64(IconEnum.Measurements),
+            toggle: true,
+            tooltipActive: 'HIDE_MEASUREMENTS',
+            show: true,
+            click: () => { this._dimensionsService.enabled = !this._dimensionsService.enabled; }
+        };
+        this._sceneOptionsService.addSceneOptionButton(button);
+    }
+    _handleInfoClick(info) {
+        const messageConfig = {
+            type: DialogType.Info,
+            messages: [new ErrorMessage(info)]
+        };
+        this._dialogService.showDialog({ data: messageConfig });
+    }
+    _prepareStandaloneConfigurator(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._cameraService.camera.position.set(0, 1, 4);
+            this._cameraService.camera.lookAt(new Vector3());
+            yield ObjectUtils.LoadHDRI(this._settingsService.settings.assetPath + '/assets/hdri/std_env_v2_B.hdr', this._sceneService.scene);
+            this._sceneService.scene.children.forEach(c => {
+                if (c instanceof Light) {
+                    this._sceneService.scene.remove(c);
+                }
+            });
+            this._sceneService.needsRender = true;
+            this.standAlone = true;
+            this.showLiteSelector = true; // always show the selections when standalone
+            this.showSelections = true; // always show the selections when standalone
+            this._loadFurnitureService.shouldLoadSelections = true;
+            this._skuAlreadySet = true;
+            if (this._settingsService.settings.options.showDownloadButton) {
+                this._createDownloadButton();
+            }
+            if (this._settingsService.settings.options.showMeasurementsButton) {
+                this._createMeasurementsButton();
+            }
+            if (this._settingsService.settings.options.development) {
+                this._createCameraSettingsButton();
+            }
+            const result = yield this._loadIOneFurnitureFromSku(new Vector3(0, 0, 0), sku, undefined, true);
+            if (result && result.furniture) {
+                this._handleFirstBuildStandalone(result.furniture);
+            }
+            else {
+                if (result.resultType === ResultType.NeedsUserInput) {
+                    this._callBackFnWhenBuildFinished = this._handleFirstBuildStandalone;
+                }
+            }
+        });
+    }
+    _handleFirstBuildStandalone(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._cameraService.moveCameraToFitObject(item);
+            if (this._settingsService.settings.options.cameraPositionFixed) {
+                this._rotationService.enableRotationFor(item);
+            }
+            if (this._settingsService.settings.options.cameraPositionFixedAndScrollbar) {
+                this._cameraService.disableRotate();
+                this._cameraService.cameraZoomOut();
+                this._cameraService.disableZoom();
+            }
+            this._sceneService.needsRender = true;
+            this._callBackFnWhenBuildFinished = undefined;
+            if (this._settingsService.settings.cameraConfig) {
+                yield this._dynamicCameraService.loadCustomCameraSettings();
+            }
+            if (this._settingsService.settings.options.enable3DInPhoto) {
+                this._threedInPhotoInitializerService.init(null, this._cameraService.camera, this._sceneService.scene, this._sceneService.renderer);
+            }
+            // save camera settings for render
+            this._cameraService.camera.updateMatrixWorld(true);
+            this._newRenderService.standAloneCameraMatrix = Array.from(this._cameraService.camera.matrixWorldInverse.elements);
+            this._buildFurnitureService.standAloneFirstBuildReady = true;
+            this._appEventService.readyToRender.next(true);
+        });
+    }
+    _handleUndefinedErrorOccured() {
+        this.showSelections = false;
+        this.showAnswers = false;
+        this._buildFurnitureService.cancelConfiguringCurrentInstance();
+    }
+    _removeButtons() {
+        this.editAddButtons.length = 0;
+        this.editCustomizeButton.length = 0;
+        this.resizeButtons.length = 0;
+    }
+    _resetSelectedElement() {
+        this._selectedElementObject = undefined;
+        this._resetElementPosition();
+        this._removeAllButtons();
+        this.showElementToolbar = false;
+    }
+    _handleRender() {
+        if (this._selectedElementObject || this.selectionToCustomize) {
+            this._resetElementPosition();
+            if (this.editAddButtons.length || this.editCustomizeButton.length > 0 || this.resizeButtons.length > 0) {
+                this._repositionButtons();
+            }
+        }
+    }
+    _selectedElementToggle(element) {
+        this.selectedElement = element;
+        const obj = element ? element.parent : undefined;
+        if (this._selectedElementObject !== obj) {
+            this.showElementToolbar = false;
+            this._selectedElementObject = obj;
+            if (this.selectedElement) {
+                this._prepareElementMenu();
+                this._prepareAddButtons();
+                if (this._settingsService.settings.options.handleParametric) {
+                    this._prepareOtherButtons();
+                }
+                const shouldBeHidden = obj.userData && obj.userData.selection && obj.userData.selection.question.indexOf('[hidden]') > -1;
+                if (this._settingsService.settings.options.instantReplace) {
+                    if (shouldBeHidden) {
+                        this.cancelElementReplace();
+                    }
+                    else {
+                        this.swapElement();
+                    }
+                }
+                setTimeout(() => {
+                    this.showElementToolbar = true;
+                    this._sceneService.needsRender = true;
+                }, 200);
+            }
+            else {
+                this._resetSelectedElement();
+            }
+        }
+    }
+    _handleBuildFinished(result) {
+        this._itemService.glassMaterialCheck(result.furniture);
+        if (this.selectedElement && result.furniture) {
+            const item = result.furniture;
+            if (this.selectedElement instanceof CustomMesh) {
+                this._selectedElementObject = this.selectedElement.parent;
+            }
+            this._prepareAddButtons();
+        }
+        if (this._callBackFnWhenBuildFinished && this.standAlone) {
+            this._callBackFnWhenBuildFinished(result.furniture);
+        }
+    }
+    _resetElementPosition() {
+        if (this.selectedElement && !this.standAlone) {
+            const yPos = ((this.selectedElement.geometry.boundingBox.max.y - this.selectedElement.geometry.boundingBox.min.y) / 2);
+            const pos = new Vector3(0, 0, 0);
+            this.selectedElement.getWorldPosition(pos);
+            pos.y += yPos;
+            this.selectedElementPosition = this._sceneService.positionInSceneToScreen(pos);
+        }
+        else {
+            this.selectedElementPosition = undefined;
+        }
+    }
+    _removeAllButtons() {
+        this._removeAddButtons();
+        this._removeResizeButtons();
+        this._removeCustomButtons();
+    }
+    _removeCustomButtons() {
+        this.editCustomizeButton.length = 0;
+    }
+    _removeAddButtons() {
+        this.editAddButtons.length = 0;
+    }
+    _removeResizeButtons() {
+        this.resizeButtons.length = 0;
+    }
+    _removeEditItems() {
+        this.editElementMenu.length = 0;
+    }
+    _prepareElementMenu() {
+        this._removeEditItems();
+        const selection = ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject);
+        if (this._settingsService.settings.options.showEditPencilConfigurator && selection) {
+            let options = this._getOptionsFromSelection(selection);
+            options = options.filter(o => {
+                return o.nodeType === 'OPT' && this._iOne.isSelectionPublished(o);
+            });
+            const len = options.length;
+            for (let i = 0; i < len; i++) {
+                this.editElementMenu.push(new CustomButton(options[i].question, () => {
+                    this._buildFurnitureService.selectSelection(options[i], this.activeMetadata);
+                    if (!this._settingsService.settings.options.instantEditMenu) {
+                        this._resetSelectedElement();
+                    }
+                }));
+            }
+        }
+    }
+    _afterLoadFromPreset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._loadingFromPreset = false;
+            this._progressService.finishDownloads();
+            if (this._itemsFromScratch.length > 0) {
+                for (let i = 0; i < this._itemsFromScratch.length; i++) {
+                    yield this._handleLoadAndBuildFurniture(this._itemsFromScratch[i].metaData, false, false, false, false, true);
+                }
+                this._itemsFromScratch.length = 0;
+            }
+            if (this._itemsNeedUserInput.length > 0) {
+                for (let i = 0; i < this._itemsNeedUserInput.length; i++) {
+                    const result = yield this._handleLoadAndBuildFurniture(this._itemsNeedUserInput[i].metaData, false, false, false, false, true);
+                    this._loadFurnitureService.addToList(this._loadFurnitureService.objectList, result);
+                }
+                this._itemsNeedUserInput.length = 0;
+            }
+            if (this._loadFurnitureService.objectListFixed.length > 0 ||
+                this._loadFurnitureService.obsoleteObjectCache.length > 0 ||
+                this._loadFurnitureService.notFixedObjectCache.length > 0 ||
+                this._loadFurnitureService.notLoaded.length > 0) {
+                this.setModelErrorDialog();
+            }
+        });
+    }
+    _isIONEObject(o) {
+        return !!o.item_schema || o.ione;
+    }
+    _prepareAddButtons() {
+        const selection = ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject);
+        this._removeAddButtons();
+        if (selection) {
+            // if (decoNode.gameObjectName.toLowerCase() === 'flat_r' ||
+            //   decoNode.gameObjectName.toLowerCase() === 'flat_l' ||
+            //   decoNode.gameObjectName.toLowerCase() === 'flat_d' ||
+            //   decoNode.gameObjectName.toLowerCase() === 'flat_u' ||
+            //   decoNode.gameObjectName.toLowerCase() === 'vert_r' ||
+            //   decoNode.gameObjectName.toLowerCase() === 'vert_l' ||
+            //   decoNode.gameObjectName.toLowerCase() === 'vert_d' ||
+            //   decoNode.gameObjectName.toLowerCase() === 'vert_u') {
+            //   if (decoNode.connectors) {
+            //     decoNode.connectors.forEach(c => c.linkedRepeatables = 'T');
+            //   }
+            // }
+            const len = selection.decoNode ? selection.decoNode.connectors.length : 0;
+            for (let i = 0; i < len; i++) {
+                let conObject = this._selectedElementObject.getObjectByName(selection.decoNode.connectors[i].connector);
+                if (!conObject && this._selectedElementObject.parent) {
+                    conObject = this._selectedElementObject.parent.getObjectByName(selection.decoNode.connectors[i].connector);
+                }
+                if (conObject && this._canShowAddButton(selection.decoNode.connectors[i], conObject)) {
+                    this.editAddButtons.push(new CustomButton('', () => {
+                        this._handleAddButtonClick(selection, selection.decoNode.connectors[i], this._selectedElementObject);
+                    }, conObject));
+                }
+            }
+        }
+        if (this.selectedElement) {
+            this._sceneService.scene.traverse((child) => {
+                if (child.name) {
+                    const customizeButton = child.name.toLowerCase().startsWith('p_');
+                    // const customizeOption: any = this._selectedElementObject.getObjectByName()
+                    if (customizeButton) {
+                        this.selectionToCustomize = child.parent;
+                        this.editCustomizeButton.push(new CustomButton('', () => {
+                            this.handleCustomizeClick();
+                        }, this._selectedElementObject));
+                    }
+                }
+            });
+        }
+    }
+    _getOppositeConnectorParts(connector) {
+        const connectorPartsArr = connector.split('_');
+        connectorPartsArr.pop(); // remove number
+        const connectorType = connectorPartsArr[connectorPartsArr.length - 1];
+        connectorPartsArr[connectorPartsArr.length - 1] = connectorType.toLowerCase() === 'f' ? 'M' : 'F';
+        return connectorPartsArr.join('_');
+    }
+    _prepareOtherButtons() {
+        this._removeResizeButtons();
+        if (this._selectedElementObject) {
+            const parent = ObjectUtils.GetParentItem(this._selectedElementObject);
+            if (parent) { // hide all connectors
+                parent.traverse(o => {
+                    if (o.name && o.name.toLowerCase().startsWith('c_')) {
+                        o.visible = false;
+                    }
+                });
+            }
+            const otherConnectors = this._selectedElementObject.children.filter(c => c instanceof Mesh && (c.name && (c.name.toLowerCase().startsWith('c_sca_') || c.name.toLowerCase().startsWith('c_rep_'))));
+            otherConnectors.forEach(o => {
+                // o.visible = true
+                this.resizeButtons.push(new CustomButton('', () => {
+                    this._handleResizeButtonClick(o.name, this._selectedElementObject);
+                }, o));
+            });
+        }
+    }
+    _handleAddButtonClick(selection, connector, parent) {
+        let after;
+        if (connector.addAdjust === 2) {
+            after = connector.connector.indexOf('_M_') > -1;
+        }
+        this._buildFurnitureService.baseElementNodeId = parent.userData && parent.userData.selection ? parent.userData.selection.nodeId : 0;
+        this._buildFurnitureService.activeConnector = connector;
+        this._buildFurnitureService.selectSelection(selection, this.activeMetadata, connector.linkedRepeatables !== 'T', after, connector.connector);
+        this._resetSelectedElement();
+    }
+    _handleResizeButtonClick(connector, parent) {
+        this._resizeService.resizeElement(connector, parent);
+    }
+    _canShowAddButton(connector, conObject) {
+        return (!conObject.connected || connector.linkedRepeatables === 'T');
+    }
+    _repositionButtons() {
+        const len = this.editAddButtons.length;
+        for (let i = 0; i < len; i++) {
+            this._repositionButton(this.editAddButtons[i]);
+        }
+        const lenr = this.resizeButtons.length;
+        for (let r = 0; r < lenr; r++) {
+            this._repositionButton(this.resizeButtons[r]);
+        }
+        const lenc = this.editCustomizeButton.length;
+        for (let c = 0; c < lenc; c++) {
+            this._repositionButton(this.editCustomizeButton[c]);
+        }
+    }
+    _repositionButton(button) {
+        const pos = new Vector3(0, 0, 0);
+        button.data.getWorldPosition(pos);
+        const screenPos = this._sceneService.positionInSceneToScreen(pos);
+        button.xPos = screenPos.x;
+        button.yPos = screenPos.y;
+        const distanceToCam = this._cameraService.camera.position.distanceTo(pos);
+        button.size = (4 / distanceToCam) * 30;
+        button.opacity = Math.max(0.25, 1 - (Math.max(7.0, (Math.round(distanceToCam * 10) / 10)) - 7));
+    }
+    _getOptionsFromSelection(baseSelection) {
+        return this._buildFurnitureService.getOptionsFromSelection(baseSelection);
+    }
+    _handleAnswerCountReceived(answerCount) {
+        this.showAnswers = answerCount > 0;
+        if (this.showAnswers) {
+            this.showLiteSelector = !this._loadingFromPreset;
+        } /* else {
+          if (this._initialStartup) {
+            // this._iOne.loadSelections();
+            this._initialStartup = false;
+          }
+        }*/
+    }
+    _handleLoadIOneFurnitureIntoSceneBySKU(sku, settings, position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const toast = new Toast();
+            toast.message = 'MODEL_LOADING';
+            this._toastService.showToast(toast);
+            yield this._connectorAdapterService.initConnector(settings ? settings.settings : this._settingsService.settings, settings ? settings.name : undefined, false, settings ? settings.externalSourceId : undefined);
+            const article = yield this._loadFurnitureService.loadArticle(sku);
+            const draggedData = {
+                name: sku,
+                constructFn: (pos) => __awaiter(this, void 0, void 0, function* () { return this._loadIOneFurnitureFromSku(pos, sku, settings); }),
+                type: itemTypeFromPlacement(article.placement),
+                iOne: true
+            };
+            this._messageBus.emit(MessageType.SetDrag, draggedData);
+            this._messageBus.emit(MessageType.StartDrag, position);
+        });
+    }
+    _handleCopyIOneFurnitureIntoSceneBySKU(original) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const toast = new Toast();
+            toast.message = 'MODEL_LOADING';
+            this._toastService.showToast(toast);
+            original.metadata.conversionGTMSend = false;
+            const draggedData = {
+                name: original.metadata.itemIdentifier,
+                constructFn: (pos) => this._loadIOneFurnitureFromOriginal(original.metadata, pos, original.rotation),
+                type: original.metadata.itemType,
+                iOne: true
+            };
+            this._messageBus.emit(MessageType.SetDrag, draggedData);
+            this._messageBus.emit(MessageType.StartDrag, original.position);
+        });
+    }
+    _loadIOneFurnitureFromOriginal(md, pos, rot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newMetaData = Object.assign({}, md);
+            newMetaData.rotation = new Euler().copy(rot);
+            return this._handleLoadAndBuildFurniture(newMetaData, true, false, false, false, false);
+        });
+    }
+    _loadIOneFurnitureFromSku(pos, sku, settings, standAlone = false) {
+        const md = {
+            position: pos,
+            itemIdentifier: sku,
+            externalSettings: settings
+        };
+        return this._handleLoadAndBuildFurniture(md, false, true, false, standAlone, false);
+    }
+    _handleCopyInstanceForFurniture(furniture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const len = furniture.length;
+            for (let i = 0; i < len; i++) {
+                const customItem = furniture[i];
+                if (customItem.metadata && customItem.metadata.itemId) {
+                    const oldInstance = customItem.metadata.itemId;
+                    const newInstance = yield this._iOne.copyInstanceAndSaveOriginalConfiguration(oldInstance, null);
+                    customItem.metadata.itemId = newInstance;
+                    customItem.userData.itemId = newInstance;
+                    customItem.metadata.originalItemId = oldInstance;
+                }
+            }
+        });
+    }
+    _handleLoadIOneFurnitureFromPreset(furniture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalSources = [];
+            const catalogData = yield this._connectorAdapterService.getCatalogDefinitionsList();
+            if (catalogData) {
+                for (const catalogItem of catalogData) {
+                    if (catalogItem.externalSourceId !== null) {
+                        const externalData = yield this._connectorAdapterService.getExternalSource(catalogItem.externalSourceId);
+                        if (externalData) {
+                            externalSources.push(externalData);
+                        }
+                    }
+                }
+            }
+            const len = furniture.length;
+            for (let i = 0; i < len; i++) {
+                if (furniture[i].externalSettings && furniture[i].externalSettings.externalSourceId === undefined) {
+                    const externalSourceObj = externalSources.find(source => source.schema === furniture[i].externalSettings.settings.schema);
+                    if (externalSourceObj && externalSourceObj.schema !== '') {
+                        if (furniture[i].externalSettings.settings['username'] !== undefined && furniture[i].externalSettings.settings['password'] !== undefined) {
+                            furniture[i].externalSettings.settings['username'] = '';
+                            furniture[i].externalSettings.settings['password'] = '';
+                        }
+                        furniture[i].externalSettings.externalSourceId = externalSourceObj.sourceId;
+                    }
+                    else {
+                        console.log('source not available');
+                    }
+                }
+                yield this._loadFurnitureFromItem(furniture[i]);
+            }
+            this._messageBus.emit(MessageType.ShouldCopyFurnitureFromPreset, true);
+        });
+    }
+    _loadFurnitureFromItem(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const position = new Vector3(item.xpos, item.ypos, item.zpos);
+            const metadata = {
+                itemName: item.item_name,
+                itemDescription: item.item_description,
+                itemId: item.item_id,
+                itemIdentifier: item.item_identifier,
+                configurable: !isNill(item.configurable) ? item.configurable : true,
+                ione: item.ione,
+                schema: item.item_schema,
+                resizable: item.resizable,
+                elevation: item.elevation,
+                elevationFixed: item.elevationFixed,
+                elevationAdjustable: item.elevationAdjustable,
+                itemType: item.item_type,
+                modelUrl: item.model_url,
+                texture: item.texture,
+                position: position,
+                rotation: new Euler(0, item.rotation, 0),
+                scale: item.scale,
+                centerPivot: true,
+                ignoreInvisible: item.ignoreInvisible,
+                updatePivotOnCreate: true,
+                opening: item.opening,
+                locked: item.locked,
+                itemGroup: item.itemGroup,
+                decos: item.decos,
+                selections: item.selections,
+                elementConfiguration: item.elementConfiguration,
+                onWall: item.onWall,
+                externalSettings: item.externalSettings,
+                conversionGTMSend: item.conversionGTMSend,
+                conversionSubmittedPrice: item.conversionSubmittedPrice
+            };
+            return this._handleLoadAndBuildFurniture(metadata, true, true, true, false, true, false);
+        });
+    }
+    _handleLoadAndBuildFurniture(furnitureData, shouldCopyInstance, looseOriginalConfiguration, fromPreset, standAlone, fromScratch, showErrorDialog = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._connectorAdapterService.initConnector(furnitureData.externalSettings ? furnitureData.externalSettings.settings : this._settingsService.settings, furnitureData.externalSettings ? furnitureData.externalSettings.name : undefined, false, furnitureData.externalSettings ? furnitureData.externalSettings.externalSourceId : null);
+            const result = yield this._loadFurnitureService.loadFurniture(furnitureData, shouldCopyInstance, looseOriginalConfiguration, standAlone, fromScratch, fromPreset)
+                .catch((errorResult) => {
+                if ((typeof errorResult === 'string' && errorResult === 'ECONNABORTED') ||
+                    errorResult.resultType === ResultType.Timeout) { // timeout
+                    errorResult = new CustomFloorGroupResult(furnitureData.itemIdentifier, furnitureData.itemName);
+                    errorResult.errorMessages.push(new ErrorMessage('TIMEOUT'));
+                    errorResult.resultType = ResultType.Timeout;
+                }
+                this._messageBus.emit(MessageType.FinishedIOneFurnitureBuild);
+                this._handleError(errorResult, showErrorDialog);
+                return errorResult;
+            });
+            this._messageBus.emit(MessageType.FinishedIOneFurnitureBuild);
+            if (result) {
+                if (result.resultType === ResultType.BuildFromScratch) {
+                    if (fromPreset) { // start configuring when loading is done
+                        result.metaData = Object.assign({}, furnitureData);
+                        this._itemsFromScratch.push(result);
+                    }
+                    else {
+                        furnitureData.position = this._floorplanService.getCenter();
+                        if (!standAlone) {
+                            this._dialogService.showDialog({
+                                data: {
+                                    type: DialogType.Warning,
+                                    title: this._dictionaryService.get('BUILD_PRODUCT_FROM_SCRATCH'),
+                                    messages: [{ message: this._dictionaryService.get('MODEL_HAS_NO_DEFAULTS') }]
+                                }
+                            });
+                            return this._handleLoadAndBuildFurniture(furnitureData, false, true, fromPreset, standAlone, true);
+                        }
+                        else {
+                            this.activeMetadata = result ? result.metaData : null;
+                            return result;
+                        }
+                    }
+                }
+                if (result.resultType === ResultType.NeedsUserInput) {
+                    result.metaData = Object.assign({}, furnitureData);
+                    if (fromPreset) { // start configuring when loading is done
+                        this._itemsNeedUserInput.push(result);
+                    }
+                    else {
+                        result.metaData.position = this._floorplanService.getCenter();
+                    }
+                }
+                if (result.resultType === ResultType.ExternalSourceNotAvailable) {
+                    this._loadFurnitureService.addToList(this._loadFurnitureService.externalSourceNotAvailable, result);
+                }
+                if (result.furniture) {
+                    if (shouldCopyInstance) {
+                        const closestWallEdge = this._roomService.getClosestWallEdge(result.furniture.position.x, result.furniture.position.z);
+                        if (result.furniture instanceof CustomWallFloorItem && result.furniture.onWall) {
+                            result.furniture.placeOnEdge(closestWallEdge);
+                            result.furniture.moveFromFloorToWall();
+                        }
+                        else if (result.furniture instanceof WallItem && !(result.furniture instanceof CustomWallFloorItem)) {
+                            result.furniture.placeOnEdge(closestWallEdge);
+                        }
+                    }
+                    if (result.furniture instanceof CustomWallItem && standAlone) {
+                        result.furniture.position.y += result.furniture.halfSize.y;
+                    }
+                    if (result.resultType === ResultType.Obsolete) {
+                        this._loadFurnitureService.addToList(this._loadFurnitureService.obsoleteObjectCache, result);
+                    }
+                    if (result.resultType === ResultType.Loaded) {
+                        if (result.metaData.configurable) {
+                            this._loadFurnitureService.addToList(this._loadFurnitureService.objectList, result);
+                        }
+                        else {
+                            this._loadFurnitureService.addToList(this._loadFurnitureService.simpleObjectList, result);
+                        }
+                    }
+                    if (result.resultType === ResultType.ConfigurationFixed) {
+                        this._loadFurnitureService.addToList(this._loadFurnitureService.objectListFixed, result);
+                    }
+                    this._addToSceneGTM(result.furniture);
+                }
+            }
+            if (!fromPreset) {
+                this._progressService.finishDownloads();
+            }
+            this.activeMetadata = result ? result.metaData : null;
+            this._sceneService.needsRender = true;
+            return result;
+        });
+    }
+    _answerSelected(result) {
+        this._loadFurnitureService.addToList(this._loadFurnitureService.objectList, result);
+    }
+    _handleError(error, showDialog) {
+        if (error.instanceId || error.sku) {
+            switch (error.resultType) {
+                case ResultType.ArticleNotFound:
+                case ResultType.Timeout:
+                case ResultType.ConfigurationNotFixed:
+                case ResultType.GameobjectNameMismatchInSource:
+                case ResultType.NoSelections:
+                case ResultType.NoDecoNodes:
+                case ResultType.ExternalSourceNotAvailable:
+                    this._loadFurnitureService.notLoaded.push(error);
+                    if (showDialog) {
+                        this._showWarning({ title: 'ERROR', messages: error.errorMessages });
+                    }
+                    break;
+                default:
+                    this._loadFurnitureService.notLoaded.push(error);
+                    if (showDialog) {
+                        this._showWarning({ title: 'ERROR', messages: [new ErrorMessage('ERROR_LOADING_FURNITURE')] });
+                    }
+            }
+        }
+        else {
+            if (showDialog) {
+                this._showWarning({ title: 'ERROR', messages: [new ErrorMessage('ERROR_LOADING_FURNITURE')] });
+            }
+        }
+        this._messageBus.emit(MessageType.UndefinedErrorOccured);
+    }
+    _handleConfigureModeChange(configuringModeChange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.standAlone) {
+                return;
+            }
+            if (configuringModeChange.configuring) {
+                this._iOne.emptySelections();
+                this._appStateService.undoDisabled = true;
+                this._appStateService.redoDisabled = true;
+                this.activeMetadata = configuringModeChange.metadata;
+                this._handleLoadAndBuildFurniture(configuringModeChange.metadata, false, false, false, false, false);
+            }
+            else {
+                this._appStateService.undoDisabled = false;
+                this._appStateService.redoDisabled = false;
+            }
+            this.showAnswers = false;
+            this.showSelections = configuringModeChange.configuring || this.standAlone;
+            this.showLiteSelector = configuringModeChange.configuring || this.standAlone;
+        });
+    }
+    _addModelDialogToolbar() {
+        this._messageService.emit(MessageType.RegisterToolbarIcon, {
+            template: this.toolbarIconModels,
+            position: 'top',
+            priority: 800
+        });
+    }
+    _showWarning(config) {
+        this._dialogService.showDialog({ data: config });
+    }
+    _addToSceneGTM(furniture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (furniture && furniture.metadata) {
+                const goodId = yield this._connectorAdapterService.getGoodIdFromArticleNr(furniture.metadata.itemIdentifier);
+                const articleFullObject = yield this._connectorAdapterService.getArticleFullObject(goodId);
+                let articleCategories;
+                if (articleFullObject && articleFullObject.publication !== undefined) {
+                    articleCategories = yield this._connectorAdapterService.getArticleCategories(articleFullObject.publication);
+                }
+                let data = {
+                    'articleNr': furniture.metadata.itemIdentifier,
+                    'product': furniture.metadata.itemName,
+                    'schema': furniture.metadata.schema
+                };
+                if (furniture.metadata.externalSettings !== undefined) {
+                    const externalData = {
+                        'externalSourceName': furniture.metadata.externalSettings.name,
+                        'externalSourceUrl': furniture.metadata.externalSettings.settings.url
+                    };
+                    data = Object.assign(Object.assign({}, data), externalData);
+                }
+                if (articleFullObject) {
+                    const articleData = {
+                        'brandId': articleFullObject.brandId,
+                        'retailFormulas': articleFullObject.retailFormulas,
+                        'turnOverGroup': articleFullObject.turnOverGroup
+                    };
+                    data = Object.assign(Object.assign({}, data), articleData);
+                }
+                if (articleCategories) {
+                    const categoryList = [];
+                    for (const category of articleCategories) {
+                        if (category.description) {
+                            categoryList.push(category.description);
+                        }
+                    }
+                    const categoryData = {
+                        'categories': categoryList
+                    };
+                    data = Object.assign(Object.assign({}, data), categoryData);
+                }
+                this._googleTagManager.sendEvent(GoogleTagManagerEvent.AddToScene, data);
+            }
+        });
+    }
+}
+ThreedselectorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ThreedselectorComponent, deps: [{ token: i1.ScreenSizeAnalysisService }, { token: i2.MatDialog }, { token: i3.HomedecoratorAppService }, { token: i4.HomedecoratorConnectorService }, { token: i5.MessageBusService }, { token: i6.LoadFurnitureService }, { token: i7.BuildFurnitureService }, { token: i8.IntegrationService }, { token: i9.HomedecoratorDictionaryService }, { token: i10.ToastService }, { token: i5.MessageBusService }, { token: i11.SceneService }, { token: i12.DialogService }, { token: i13.CameraService }, { token: i14.PresetsService }, { token: i15.ItemService }, { token: i16.HomedecoratorSettingsService }, { token: i17.SceneOptionsService }, { token: i18.DimensionsService }, { token: i19.HomedecoratorAppEventService }, { token: i20.FloorplanService }, { token: i21.FloorService }, { token: i22.HomedecoratorIconCacheService }, { token: i23.ArService }, { token: i24.GoogleTagManagerService }, { token: i25.ErrorService }, { token: i26.RotationService }, { token: i27.RoomService }, { token: i28.AppStateService }, { token: i29.ProgressService }, { token: i30.AnimationService }, { token: i31.ResizeService }, { token: i32.CustomizerService }, { token: i33.DynamicCameraService }, { token: i34.ThreedInPhotoInitializerService }, { token: i35.RenderService }, { token: i36.NewRenderService }, { token: i37.HomedecoratorConnectorAdapterService }], target: i0.ɵɵFactoryTarget.Component });
+ThreedselectorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ThreedselectorComponent, selector: "rp-threedselector", inputs: { selections: "selections" }, outputs: { customizeButtonClicked: "customizeButtonClicked" }, viewQueries: [{ propertyName: "toolbarIconModels", first: true, predicate: ["toolbarIconModels"], descendants: true, static: true }, { propertyName: "selectedThreedObjectCustomizationSidebar", first: true, predicate: ["selectedThreedObjectCustomizationSidebar"], descendants: true, static: true }, { propertyName: "selectedThreedObjectAnimationSidebar", first: true, predicate: ["selectedThreedObjectAnimationSidebar"], descendants: true, static: true }, { propertyName: "customizeButtonClicked", first: true, predicate: ElementToolbarComponent, descendants: true, static: true }], ngImport: i0, template: "<rp-lite-selector *ngIf=\"!standAlone\" class=\"floating\"\r\n                  [(show)]=\"showLiteSelector\"\r\n                  [metadata]=\"activeMetadata\"\r\n                  [showSelections]=\"showSelections\"\r\n                  [showAnswers]=\"showAnswers\"\r\n                  (showChange)=\"handleShowChangeSelector($event)\"\r\n></rp-lite-selector>\r\n<ng-container *ngIf=\"showElementToolbar\">\r\n  <rp-element-toolbar class=\"rp-element-toolbar floating\" [class.custom]=\"standAlone\" @showElementToolbar\r\n                      [editMenu]=\"editElementMenu\"\r\n                      [showSwap]=\"showSwapButton\"\r\n                      [showPointer]=\"selectedElementPosition !== undefined\"\r\n                      (swapClicked)=\"swapElement()\"\r\n                      (deleteClicked)=\"deleteElement()\"\r\n                      (animationClicked)=\"openAnimationSidebar()\"\r\n  ></rp-element-toolbar>\r\n  <rp-element-buttons class=\"rp-element-buttons floating\" @showElementToolbar\r\n                      [elementPointer]=\"elementToolbar?.elementPointer\"\r\n                      [addButtons]=\"editAddButtons\"\r\n                      [customizeButtons]=\"editCustomizeButton\"\r\n                      [resizeButtons]=\"resizeButtons\"\r\n                      [elementPosition]=\"selectedElementPosition\"\r\n                      (customizeButtonClicked)=\"handleCustomizeClick()\"\r\n  ></rp-element-buttons>\r\n</ng-container>\r\n\r\n<ng-container *ngIf=\"showCustomizeButtons\">\r\n  <rp-element-buttons class=\"rp-element-buttons floating\"\r\n                      [elementPointer]=\"elementToolbar?.elementPointer\"\r\n                      [customizeButtons]=\"editCustomizeButton\"\r\n                      [elementPosition]=\"selectedElementPosition\"\r\n                      (customizeButtonClicked)=\"handleCustomizeClick()\"\r\n  ></rp-element-buttons>\r\n</ng-container>\r\n\r\n<ng-template #toolbarIconModels>\r\n  <rp-toolbar-icon\r\n    matIcon=\"format_list_bulleted\"\r\n    tooltip=\"{{iconName.Objects | localize}}\"\r\n    (onClick)=\"setModelErrorDialog()\"\r\n    [showLabel]=\"shouldShowLabel\"\r\n  ></rp-toolbar-icon>\r\n</ng-template>\r\n\r\n<ng-template #selectedThreedObjectAnimationSidebar>\r\n  <header class=\"drawer__header\">\r\n    <h2 class=\"mat-title\" [textContent]=\"'ANIMATE' | localize\"></h2>\r\n  </header>\r\n  <rp-animation>\r\n\r\n  </rp-animation>\r\n</ng-template>\r\n\r\n<ng-template #selectedThreedObjectCustomizationSidebar>\r\n  <header class=\"drawer__header\">\r\n    <h2 class=\"mat-title\" [textContent]=\"'CUSTOMIZE' | localize\"></h2>\r\n  </header>\r\n  <rp-customizer\r\n    [selection]=\"selectionToCustomize\"\r\n  ></rp-customizer>\r\n</ng-template>\r\n\r\n<div class=\"slider-container\">\r\n  <rp-element-slider class=\"rp-element-slider\"></rp-element-slider>\r\n</div>\r\n", styles: [":host{position:absolute;top:0;left:0;pointer-events:none;margin:0;padding:0;width:100%;height:100%;overflow:hidden}:host>*{pointer-events:all}.input-wrapper{display:flex;flex-direction:column}.flex-wrap{display:flex;flex-flow:column nowrap;height:100%}.logo-menu-5th{position:absolute;top:220px;left:84px}.logo-menu-5th.front .mat-raised-button{width:170px;text-align:left}.sidebar{position:absolute;left:0;top:0;height:100vh;max-width:30%;width:400px;background:#fff;padding:0 20px;box-shadow:0 0 20px #00000040}.on-top{z-index:3}.solid-background{fill:#fff;background:white}.solid-background>*{fill:#fff;background:white}.button-close{height:36px;width:36px;min-width:initial;padding:0;border:none;position:absolute;right:20px;top:15px;border-radius:50%}.remove-all{position:absolute;top:15px;right:71px}\n"], components: [{ type: i38.LiteSelectorComponent, selector: "rp-lite-selector", inputs: ["showAnswers", "show", "showSelections", "showLabel", "canClose", "metadata", "customDimensions"], outputs: ["showChange", "answerChosen"] }, { type: i39.ElementToolbarComponent, selector: "rp-element-toolbar", inputs: ["editMenu", "showPointer", "showSwap"], outputs: ["deleteClicked", "swapClicked", "animationClicked"] }, { type: i40.ElementButtonsComponent, selector: "rp-element-buttons", inputs: ["addButtons", "customizeButtons", "resizeButtons", "elementPointer", "elementPosition"], outputs: ["customizeButtonClicked"] }, { type: i41.ToolbarIconComponent, selector: "rp-toolbar-icon", inputs: ["matIcon", "svgIcon", "tooltip", "disabled", "showLabel"], outputs: ["onClick"] }, { type: i42.AnimationComponent, selector: "rp-animation" }, { type: i43.CustomizerComponent, selector: "rp-customizer", inputs: ["selection"] }, { type: i44.ElementSliderComponent, selector: "rp-element-slider" }], directives: [{ type: i45.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "localize": i46.LocalizePipe }, animations: [
+        trigger('showElementToolbar', [
+            state('void', style({ 'opacity': '0' })),
+            state('*', style({ 'opacity': '1' })),
+            transition('void => *', animate('500ms ease'))
+        ])
+    ] /*,
+    changeDetection: ChangeDetectionStrategy.OnPush*/ });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ThreedselectorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rp-threedselector',
+                    templateUrl: './threedselector.component.html',
+                    styleUrls: ['./threedselector.component.scss'],
+                    animations: [
+                        trigger('showElementToolbar', [
+                            state('void', style({ 'opacity': '0' })),
+                            state('*', style({ 'opacity': '1' })),
+                            transition('void => *', animate('500ms ease'))
+                        ])
+                    ] /*,
+                    changeDetection: ChangeDetectionStrategy.OnPush*/
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ScreenSizeAnalysisService }, { type: i2.MatDialog }, { type: i3.HomedecoratorAppService }, { type: i4.HomedecoratorConnectorService }, { type: i5.MessageBusService }, { type: i6.LoadFurnitureService }, { type: i7.BuildFurnitureService }, { type: i8.IntegrationService }, { type: i9.HomedecoratorDictionaryService }, { type: i10.ToastService }, { type: i5.MessageBusService }, { type: i11.SceneService }, { type: i12.DialogService }, { type: i13.CameraService }, { type: i14.PresetsService }, { type: i15.ItemService }, { type: i16.HomedecoratorSettingsService }, { type: i17.SceneOptionsService }, { type: i18.DimensionsService }, { type: i19.HomedecoratorAppEventService }, { type: i20.FloorplanService }, { type: i21.FloorService }, { type: i22.HomedecoratorIconCacheService }, { type: i23.ArService }, { type: i24.GoogleTagManagerService }, { type: i25.ErrorService }, { type: i26.RotationService }, { type: i27.RoomService }, { type: i28.AppStateService }, { type: i29.ProgressService }, { type: i30.AnimationService }, { type: i31.ResizeService }, { type: i32.CustomizerService }, { type: i33.DynamicCameraService }, { type: i34.ThreedInPhotoInitializerService }, { type: i35.RenderService }, { type: i36.NewRenderService }, { type: i37.HomedecoratorConnectorAdapterService }]; }, propDecorators: { toolbarIconModels: [{
+                type: ViewChild,
+                args: ['toolbarIconModels', { static: true }]
+            }], selectedThreedObjectCustomizationSidebar: [{
+                type: ViewChild,
+                args: ['selectedThreedObjectCustomizationSidebar', { static: true }]
+            }], selectedThreedObjectAnimationSidebar: [{
+                type: ViewChild,
+                args: ['selectedThreedObjectAnimationSidebar', { static: true }]
+            }], customizeButtonClicked: [{
+                type: ViewChild,
+                args: [ElementToolbarComponent, { static: true }]
+            }, {
+                type: Output
+            }], selections: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"threedselector.component.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/threedselector/threedselector/threedselector.component.ts","../../../../../../../src/client/app/plugins/threedselector/threedselector/threedselector.component.html"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, Input, OnDestroy, OnInit, Output, TemplateRef, ViewChild} from '@angular/core';\r\nimport {\r\n  AxesHelper,\r\n  BufferAttribute,\r\n  Color,\r\n  DirectionalLight,\r\n  Euler, Light,\r\n  Mesh,\r\n  MeshStandardMaterial,\r\n  Object3D, Path,\r\n  PlaneGeometry, Shape, ShapeGeometry,\r\n  Vector2,\r\n  Vector3\r\n} from 'three';\r\nimport {Subscription} from 'rxjs';\r\nimport {Selection} from '@colijnit/configuratorapi/build/model/selection';\r\nimport {MatDialog} from '@angular/material/dialog';\r\nimport {animate, state, style, transition, trigger} from '@angular/animations';\r\nimport {Article} from '@colijnit/configuratorapi/build/model/article';\r\nimport {IconName} from '../../../core/enum/icon-name.enum';\r\nimport {ElementToolbarComponent} from '../element-toolbar/element-toolbar.component';\r\nimport {CustomButton} from '../../../core/model/custom-button';\r\nimport {HalfEdge, WallItem} from '../../core3d/items/wall-objects';\r\nimport {CustomObject3D} from '../../core3d/items/custom-objects';\r\nimport {isItemGroupType, isWallItemGroupType, itemTypeFromPlacement} from '../../core3d/items/factory';\r\nimport {Metadata} from '../../core3d/items/metadata';\r\nimport {Item} from '../../core3d/items/item';\r\nimport {ItemGroup} from '../../core3d/items/item-group';\r\nimport {CustomFloorGroupResult} from '../../core3d/model/custom-floor-group-result';\r\nimport {Texture} from '../../../core/model/texture';\r\nimport {ScreenSizeAnalysisService} from '../../../shared/screen-size-analysis/screen-size-analysis.service';\r\nimport {HomedecoratorAppService} from '../../../core/service/homedecorator-app.service';\r\nimport {HomedecoratorConnectorService} from '../../../core/service/homedecorator-connector.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {LoadFurnitureService} from './service/load-furniture.service';\r\nimport {BuildFurnitureService, ConfiguringModeChangeInterface} from './service/build-furniture.service';\r\nimport {IntegrationService} from '../../../core/service/integration.service';\r\nimport {HomedecoratorDictionaryService} from '../../../core/service/homedecorator-dictionary.service';\r\nimport {ToastService} from '../../../core/service/toast.service';\r\nimport {SceneService} from '../../core3d/service/scene.service';\r\nimport {DialogService} from '../../../shared/dialog/service/dialog.service';\r\nimport {CameraService} from '../../core3d/service/camera.service';\r\nimport {PresetsService} from '../../../core/service/presets.service';\r\nimport {ItemService} from '../../core3d/service/item.service';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {SceneOptionsService} from '../../core3d/service/scene-options.service';\r\nimport {DimensionsService} from './service/dimensions.service';\r\nimport {HomedecoratorAppEventService} from '../../../core/service/homedecorator-app-event.service';\r\nimport {FloorplanService} from '../../room-planner/components/floorplanner/service/floorplan.service';\r\nimport {FloorService} from '../../core3d/service/floor.service';\r\nimport {HomedecoratorIconCacheService} from '../../../core/service/homedecorator-icon-cache.service';\r\nimport {ArService} from '../../core3d/service/ar.service';\r\nimport {GoogleTagManagerService} from '../../../service/google-tag-manager.service';\r\nimport {ErrorService} from '../../../core/service/error.service';\r\nimport {RotationService} from '../../core3d/service/rotation.service';\r\nimport {RoomService} from '../../room-planner/components/floorplanner/service/room.service';\r\nimport {AppStateService} from '../../../core/service/app-state.service';\r\nimport {ProgressService} from '../../../core/service/progress.service';\r\nimport {AnimationService} from './service/animation.service';\r\nimport {ResizeService} from './service/resize.service';\r\nimport {CustomizerService} from '../../lite-selector/lite-selector/service/customizer.service';\r\nimport {DynamicCameraService} from '../../../core/service/dynamic-camera.service';\r\nimport {ThreedInPhotoInitializerService} from '../../threed-in-photo/services/threed-in-photo-initializer.service';\r\nimport {RenderService} from '../../render/service/render.service';\r\nimport {NewRenderService} from '../../render/service/new-render.service';\r\nimport {HomedecoratorConnectorAdapterService} from '../../../core/service/homedecorator-connector-adapter.service';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {ScreenSizeInfo} from '../../../shared/screen-size-analysis/screen-size-info';\r\nimport {WallItemGroup} from '../../core3d/items/wall-objects';\r\nimport {ObjectUtils} from '../../../core/utils/object.utils';\r\nimport {ModelDialogComponent} from '../../../shared/model-dialog/model-dialog.component';\r\nimport {SceneOptionButtonInterface} from '../../core3d/interface/scene-option-button.interface';\r\nimport {IconEnum} from '../../../core/enum/icon.enum';\r\nimport {DialogConfig} from '../../../shared/dialog/interface/dialog-config.interface';\r\nimport {DialogType} from '../../../shared/dialog/enum/dialog-type.enum';\r\nimport {ErrorMessage} from '../../../core/model/error-message';\r\nimport {ResultType} from '../../core3d/enum/result-type.enum';\r\nimport {CustomMesh} from '../../core3d/items/custom-objects';\r\nimport {ExternalSettingsInterface} from '../../../core/interface/external-settings.interface';\r\nimport {Toast} from '../../../core/model/toast';\r\nimport {DraggedData} from '../../core3d/interface/dragged-data.interface';\r\nimport {isNill} from '../../../core/utils/function/is-nill.function';\r\nimport {CustomWallFloorItem} from '../../core3d/items/custom-wall-floor-item';\r\nimport {CustomWallItem} from '../../core3d/items/custom-wall-item';\r\nimport {GoogleTagManagerEvent} from '../../../core/enum/google-tag-manager-event.enum';\r\nimport {CameraSettingsDialogComponent} from '../../../shared/camera-settings-dialog/camera-settings-dialog.component';\r\nimport {ArticleCategory} from '@colijnit/configuratorapi/build/model/article-category';\r\nimport {ExternalSource} from '@colijnit/articleapi/build/model/external-source.bo';\r\nimport {CatalogDefinition} from '@colijnit/articleapi/build/model/catalog-definition.bo';\r\nimport {NodeType} from '@colijnit/configuratorapi/build/enum/node-type.enum';\r\nimport {MaterialUtils} from '../../../core/utils/material.utils';\r\nimport {direction} from 'html2canvas/dist/types/css/property-descriptors/direction';\r\nimport * as THREE from 'three';\r\nimport {Utils} from '../../core3d/core/utils';\r\n\r\n@Component({\r\n  selector: 'rp-threedselector',\r\n  templateUrl: './threedselector.component.html',\r\n  styleUrls: ['./threedselector.component.scss'],\r\n  animations: [\r\n    trigger('showElementToolbar', [\r\n      state('void', style({'opacity': '0'})),\r\n      state('*', style({'opacity': '1'})),\r\n      transition('void => *', animate('500ms ease'))\r\n    ])\r\n  ]/*,\r\n  changeDetection: ChangeDetectionStrategy.OnPush*/\r\n})\r\nexport class ThreedselectorComponent implements OnInit, OnDestroy {\r\n  public readonly iconName: typeof IconName = IconName;\r\n\r\n  @ViewChild('toolbarIconModels', { static: true }) toolbarIconModels: TemplateRef<any>;\r\n  @ViewChild('selectedThreedObjectCustomizationSidebar', {static: true}) selectedThreedObjectCustomizationSidebar: TemplateRef<any>;\r\n  @ViewChild('selectedThreedObjectAnimationSidebar', {static: true}) selectedThreedObjectAnimationSidebar: TemplateRef<any>;\r\n  @ViewChild(ElementToolbarComponent, { static: true })\r\n\r\n  @Output()\r\n  public customizeButtonClicked: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @Input()\r\n  public selections: Selection[] = [];\r\n\r\n  public elementToolbar: ElementToolbarComponent;\r\n\r\n  public editElementMenu: CustomButton[] = [];\r\n  public editAddButtons: CustomButton[] = [];\r\n  public editCustomizeButton: CustomButton[] = [];\r\n  public resizeButtons: CustomButton[] = [];\r\n\r\n  public selectedElementPosition: Vector2 = new Vector2();\r\n\r\n  public showElementToolbar = false;\r\n  public showLiteSelector = false;\r\n  public showSelections = false;\r\n  public showAnswers = false;\r\n  public showCustomizeButtons = false;\r\n  public showSwapButton = true;\r\n  public standAlone: boolean = false;\r\n  public shouldShowLabel: boolean = false;\r\n  public activeMetadata: Metadata;\r\n  public selectionToCustomize: any;\r\n  public selectedObject: Item | ItemGroup;\r\n  public selectedElement: Mesh;\r\n\r\n  private _selectedElementObject: CustomObject3D;\r\n  private _skuAlreadySet: boolean = false;\r\n  private _itemsFromScratch: CustomFloorGroupResult[] = [];\r\n  private _itemsNeedUserInput: CustomFloorGroupResult[] = [];\r\n  private _standaloneFloors: Texture[];\r\n  private _subs: Subscription[] = [];\r\n  private _loadingFromPreset: boolean = false;\r\n  private _callBackFnWhenBuildFinished: Function;\r\n\r\n  constructor(\r\n    public screenSizeService: ScreenSizeAnalysisService,\r\n    private _dialog: MatDialog,\r\n    private _appService: HomedecoratorAppService,\r\n    private _iOne: HomedecoratorConnectorService,\r\n    private _messageBus: MessageBusService,\r\n    private _loadFurnitureService: LoadFurnitureService,\r\n    private _buildFurnitureService: BuildFurnitureService,\r\n    private _integrationService: IntegrationService,\r\n    private _dictionaryService: HomedecoratorDictionaryService,\r\n    private _toastService: ToastService,\r\n    private _messageService: MessageBusService,\r\n    private _sceneService: SceneService,\r\n    private _dialogService: DialogService,\r\n    private _cameraService: CameraService,\r\n    private _presetsService: PresetsService,\r\n    private _itemService: ItemService,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _sceneOptionsService: SceneOptionsService,\r\n    private _dimensionsService: DimensionsService,\r\n    private _appEventService: HomedecoratorAppEventService,\r\n    private _floorplanService: FloorplanService,\r\n    private _floorService: FloorService,\r\n    private _iconCacheService: HomedecoratorIconCacheService,\r\n    private _arService: ArService,\r\n    private _googleTagManager: GoogleTagManagerService,\r\n    private _errorService: ErrorService,\r\n    private _rotationService: RotationService,\r\n    private _roomService: RoomService,\r\n    private _appStateService: AppStateService,\r\n    private _progressService: ProgressService,\r\n    private _animationService: AnimationService,\r\n    private _resizeService: ResizeService,\r\n    private _customizerService: CustomizerService,\r\n    private _dynamicCameraService: DynamicCameraService,\r\n    private _threedInPhotoInitializerService: ThreedInPhotoInitializerService,\r\n    private _renderService: RenderService,\r\n    private _newRenderService: NewRenderService,\r\n      private _connectorAdapterService: HomedecoratorConnectorAdapterService\r\n  ) {\r\n    this._presetsService.register(this);\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._subs.push(\r\n      this._appEventService.answerCountReceived.subscribe((answerCount: number) => this._handleAnswerCountReceived(answerCount)),\r\n      this._messageBus.subscribe(MessageType.LoadIOneFurnitureIntoSceneBySKU,\r\n        ({sku, settings, position}: { sku: string, settings: any, position: { x: number, y: number, z?: number } }) =>\r\n          this._handleLoadIOneFurnitureIntoSceneBySKU(sku, settings, position)\r\n      ),\r\n      this._messageBus.subscribe(MessageType.CopyIOneFurnitureIntoSceneBySKU, (original: Item) =>\r\n        this._handleCopyIOneFurnitureIntoSceneBySKU(original)\r\n      ),\r\n      this._buildFurnitureService.configureModeChanged.subscribe(configuringModeChange =>\r\n        this._handleConfigureModeChange(configuringModeChange)),\r\n      this._buildFurnitureService.toggleSelectedElement.subscribe((element: Mesh) => this._selectedElementToggle(element)),\r\n      this._buildFurnitureService.buildFinished.subscribe((result: CustomFloorGroupResult) => this._handleBuildFinished(result)),\r\n      this._buildFurnitureService.answerSelected.subscribe((result: CustomFloorGroupResult) => this._answerSelected(result)),\r\n      this._sceneService.onAfterRender.subscribe(() => this._handleRender()),\r\n      this._appService.skuSet.subscribe(sku => this._handleSkuSet(sku)),\r\n      this._appEventService.articleInfoReceived.subscribe(info => this._handleInfoClick(info)),\r\n      this._messageService.subscribe(MessageType.UndefinedErrorOccured, () => this._handleUndefinedErrorOccured()),\r\n      this._presetsService.afterLoad.subscribe(() => this._afterLoadFromPreset()),\r\n      this._messageBus.subscribe(MessageType.Undo, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.Redo, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.StartWithEmptyRoom, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.StartWithPreset, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.LoadRoomFromPreset, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.LoadRoomFromCloud, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.NewRoom, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.ResetRoomplan, () => this._clearItems()),\r\n      this._messageBus.subscribe(MessageType.LoadScaledDiagram, () => this._clearItems()),\r\n      this._presetsService.beforeLoad.subscribe(() => this._clearItems()),\r\n      this._messageService.subscribe(MessageType.ItemSelected, (item) => this.objectSelected(item)),\r\n      this._messageService.subscribe(MessageType.ItemUnselected, () => this._removeButtons()),\r\n      this.screenSizeService.screenSizeChanged.subscribe((info: ScreenSizeInfo) => {\r\n        this.shouldShowLabel = info.isPhoneSize;\r\n      }),\r\n      this._settingsService.settingsLoaded.subscribe((loaded: boolean) => {\r\n        if (loaded) {\r\n          this.showSwapButton = !this._settingsService.settings.options.instantReplace;\r\n        }\r\n      })\r\n    );\r\n\r\n    this._addModelDialogToolbar();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(sub => sub.unsubscribe());\r\n  }\r\n\r\n  public async copySceneInstance(saveAs: boolean): Promise<void> {\r\n    if (/*!this._settingsService.isPrivate && */saveAs) {\r\n      const furniture = this._itemService.getIOneFurniture();\r\n      return this._handleCopyInstanceForFurniture(furniture);\r\n    } else {\r\n      return Promise.resolve();\r\n    }\r\n  }\r\n\r\n  public async loadObjects({furniture}): Promise<any> {\r\n    if (!furniture) {\r\n      return null;\r\n    }\r\n    this._loadingFromPreset = true;\r\n    const iONEObjectsToLoad = furniture.filter(o => this._isIONEObject(o));\r\n    furniture\r\n      .filter((o) => isItemGroupType(o.item_type))\r\n      .forEach(g => {\r\n        let groupAdded: boolean = false;\r\n        const itemGroup = isWallItemGroupType(g.item_type) ? new WallItemGroup() : new ItemGroup();\r\n        itemGroup.locked = g.locked;\r\n        itemGroup.position.set(g.xpos, g.ypos, g.zpos);\r\n        itemGroup.rotation.set(0, g.rotation, 0);\r\n        const children = g.children;\r\n        children.forEach(ch => {\r\n          if (this._isIONEObject(ch)) {\r\n            if (!groupAdded) {\r\n              this._itemService.addItem(itemGroup);\r\n              groupAdded = true;\r\n            }\r\n            ch.itemGroup = itemGroup;\r\n            iONEObjectsToLoad.push(ch);\r\n          }\r\n        });\r\n      });\r\n\r\n    return this._handleLoadIOneFurnitureFromPreset(iONEObjectsToLoad);\r\n  }\r\n\r\n  public getObjects(): any {\r\n    // return {furniture: this.threeService.model.saveFurniture()};\r\n  }\r\n\r\n  public objectSelected(object: Item | ItemGroup) {\r\n    this._removeCustomButtons();\r\n    this.showCustomizeButtons = true;\r\n    this.selectedObject = object;\r\n    object.traverse((child) => {\r\n      const customizeButton: any = child.name && child.name.toLowerCase().startsWith('p_');\r\n      if (customizeButton) {\r\n        this.selectionToCustomize = child.parent;\r\n        this.editCustomizeButton.push(new CustomButton('', () => {\r\n            this.handleCustomizeClick();\r\n          },\r\n          this.selectionToCustomize));\r\n      }\r\n    });\r\n    this._handleRender();\r\n  }\r\n\r\n  public handleCustomizeClick(): void {\r\n    this._customizerService.selectedObject = this.selectionToCustomize;\r\n    this._messageService.emit(MessageType.SetLeftSidebar, this.selectedThreedObjectCustomizationSidebar);\r\n  }\r\n\r\n  public swapElement(): void {\r\n    if (this._selectedElementObject) {\r\n      this._buildFurnitureService.replaceSelection(ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject), this.activeMetadata);\r\n      if (!this._settingsService.settings.options.instantReplace) {\r\n        this._resetSelectedElement();\r\n      }\r\n    }\r\n  }\r\n\r\n  public deleteElement(): void {\r\n    if (this._selectedElementObject) {\r\n      this._buildFurnitureService.deleteSelection(ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject), this.activeMetadata);\r\n      this._resetSelectedElement();\r\n    }\r\n  }\r\n\r\n  public cancelElementReplace(rebuild: boolean = false): void {\r\n    this._buildFurnitureService.cancelAnswer(this.activeMetadata, false, true);\r\n    this._resetSelectedElement();\r\n  }\r\n\r\n  public openAnimationSidebar(): void {\r\n    this._messageService.emit(MessageType.SetLeftSidebar, this.selectedThreedObjectAnimationSidebar);\r\n  }\r\n\r\n  public handleShowChangeSelector(show: boolean): void {\r\n    if (!show) {\r\n      if (this.showAnswers) {\r\n        this._buildFurnitureService.cancelAnswer(this.activeMetadata);\r\n      }\r\n      this._buildFurnitureService.cancelConfiguringCurrentInstance();\r\n    }\r\n  }\r\n\r\n  public setModelErrorDialog(): void {\r\n    this._dialog.open(ModelDialogComponent);\r\n  }\r\n\r\n  private _clearItems(): void {\r\n    this._itemsFromScratch.length = 0;\r\n  }\r\n\r\n  private async _handleSkuSet(sku: string): Promise<void> {\r\n    if (sku) {\r\n      this._subs.push(\r\n        this._iOne.controllerInitialized.subscribe(async (initialized: boolean) => {\r\n          if (initialized) {\r\n            this._prepareStandaloneConfigurator(sku);\r\n          }\r\n        }),\r\n        this._appService.floorTexturesLoaded.subscribe(textures => this._handleFloorsLoaded(textures)),\r\n      );\r\n      const arButton: SceneOptionButtonInterface = {\r\n        id: 2,\r\n        elementId: 'standalone_ar_session',\r\n        tooltip: 'START_AR_SESSION',\r\n        order: 10,\r\n        image: this._iconCacheService.getIconAsBase64(IconEnum.ArCircle),\r\n        toggle: false,\r\n        show: await this._arService.arSupported() &&\r\n          this._settingsService.settings.options.showStandaloneARButton &&\r\n          this._settingsService.settings.options.arEnabled,\r\n        click: () => {\r\n          const object = (this._itemService.getConfigurables()[0] as any)/*.cloneVisible()*/;\r\n          if (object) {\r\n            this._sceneService.arMode = true;\r\n            this._sceneService.addObject(object);\r\n          }\r\n        }\r\n      };\r\n      this._sceneOptionsService.addSceneOptionButton(arButton);\r\n    }\r\n  }\r\n\r\n  private async _handleFloorsLoaded(textures: Texture[]): Promise<void> {\r\n    if (textures) {\r\n      let defaultFloor: Texture;\r\n      if (this._settingsService.settings.options.useStandaloneFloors) {\r\n        this._standaloneFloors = this._appService.getFloorsStandalone();\r\n        defaultFloor = this._standaloneFloors.find(f => f.defaultStandalone);\r\n      }\r\n      let floorGeometry;\r\n      if (defaultFloor && defaultFloor.simplePlane) {\r\n        floorGeometry = new PlaneGeometry(6, 6);\r\n      } else {\r\n        const corners = [\r\n          this._floorplanService.newCorner(-3, 3),\r\n          this._floorplanService.newCorner(-3, -3),\r\n          this._floorplanService.newCorner(3, -3),\r\n          this._floorplanService.newCorner(3, 3),\r\n        ];\r\n        const points = corners.map(corner => new Vector2(corner.x, corner.y));\r\n        const shape = new Shape(points);\r\n        floorGeometry = new ShapeGeometry(shape).center();\r\n      }\r\n      await this._floorService.generateFloorPlane('white', defaultFloor, undefined, undefined, floorGeometry);\r\n      this._floorService.getFloorPlane().visible = this._settingsService.settings.options.useStandaloneFloors;\r\n      this._sceneService.scene.background = new Color(parseInt(this._settingsService.settings.standaloneSceneBackgroundColor, 0));\r\n      this._sceneService.needsRender = true;\r\n      if (this._standaloneFloors && this._standaloneFloors.length > 1) {\r\n        this._upsertFloorButtons(defaultFloor);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _upsertFloorButtons(activeFloor: Texture): void {\r\n    const floorButtons: SceneOptionButtonInterface[] = [];\r\n    let newFloorButton: SceneOptionButtonInterface;\r\n    this._standaloneFloors.forEach((f, index) => {\r\n      if (f !== activeFloor) {\r\n        newFloorButton = {\r\n          id: index,\r\n          elementId: `standalone_floor_${f.name}`,\r\n          tooltip: f.name,\r\n          class: 'circle',\r\n          show: false,\r\n          object: f,\r\n          image: this._settingsService.settings.assetPath + f.url,\r\n          click: (floor) => this._changeStandaloneFloor(floor)\r\n        };\r\n        floorButtons.push(newFloorButton);\r\n      }\r\n    });\r\n    const activeFloorButton: SceneOptionButtonInterface = {\r\n      id: 10,\r\n      elementId: 'standalone_change_floor',\r\n      tooltip: 'CHANGE_FLOOR',\r\n      order: 8,\r\n      class: 'circle',\r\n      object: activeFloor,\r\n      children: floorButtons,\r\n      show: true,\r\n      image: this._settingsService.settings.assetPath + activeFloor.url\r\n    };\r\n    this._sceneOptionsService.updateSceneOptionButton(activeFloorButton);\r\n  }\r\n\r\n  private async _changeStandaloneFloor(floor: Texture): Promise<void> {\r\n    await this._floorService.setFloorTexture(null, floor);\r\n    this._upsertFloorButtons(floor);\r\n    this._sceneService.updatePathTracer();\r\n  }\r\n\r\n  private _createDownloadButton(): void {\r\n    const download3DModelButton: SceneOptionButtonInterface = {\r\n      id: 100,\r\n      elementId: 'standalone_download_model',\r\n      tooltip: 'DOWNLOAD_MODEL',\r\n      order: 2,\r\n      class: 'circle',\r\n      label: 'cloud_download',\r\n      show: true,\r\n      click: () => this._buildFurnitureService.downloadCurrentCustomFloorgroup()\r\n    };\r\n    this._sceneOptionsService.updateSceneOptionButton(download3DModelButton);\r\n  }\r\n\r\n  private _createCameraSettingsButton(): void {\r\n    const cameraSettingsButton: SceneOptionButtonInterface = {\r\n      id: 110,\r\n      elementId: 'standalone_camera_settings',\r\n      tooltip: 'CAMERA_SETTINGS',\r\n      order: 1,\r\n      class: 'circle',\r\n      label: 'camera_settings',\r\n      show: true,\r\n      click: () => this._openCameraSettingsDialog()\r\n    };\r\n    this._sceneOptionsService.updateSceneOptionButton(cameraSettingsButton);\r\n  }\r\n\r\n  private _openCameraSettingsDialog(): void {\r\n    this._dialog.open(CameraSettingsDialogComponent, {\r\n      width: '600px'\r\n    });\r\n  }\r\n\r\n  private _createMeasurementsButton(): void {\r\n    const button: SceneOptionButtonInterface = {\r\n      id: 1,\r\n      elementId: 'standalone_show_measurements',\r\n      tooltip: 'SHOW_MEASUREMENTS',\r\n      order: 11,\r\n      image: this._iconCacheService.getIconAsBase64(IconEnum.Measurements),\r\n      toggle: true,\r\n      tooltipActive: 'HIDE_MEASUREMENTS',\r\n      show: true,\r\n      click: () => { this._dimensionsService.enabled = !this._dimensionsService.enabled; }\r\n    };\r\n    this._sceneOptionsService.addSceneOptionButton(button);\r\n  }\r\n\r\n  private _handleInfoClick(info: string): void {\r\n    const messageConfig: DialogConfig = {\r\n      type: DialogType.Info,\r\n      messages: [new ErrorMessage(info)]\r\n    };\r\n    this._dialogService.showDialog({data: messageConfig});\r\n  }\r\n\r\n  private async _prepareStandaloneConfigurator(sku): Promise<void> {\r\n    this._cameraService.camera.position.set(0, 1, 4);\r\n    this._cameraService.camera.lookAt(new Vector3());\r\n    await ObjectUtils.LoadHDRI(this._settingsService.settings.assetPath + '/assets/hdri/std_env_v2_B.hdr', this._sceneService.scene);\r\n    this._sceneService.scene.children.forEach(c => {\r\n      if (c instanceof Light) {\r\n        this._sceneService.scene.remove(c);\r\n      }\r\n    });\r\n    this._sceneService.needsRender = true;\r\n\r\n    this.standAlone = true;\r\n    this.showLiteSelector = true; // always show the selections when standalone\r\n    this.showSelections = true; // always show the selections when standalone\r\n    this._loadFurnitureService.shouldLoadSelections = true;\r\n    this._skuAlreadySet = true;\r\n    if (this._settingsService.settings.options.showDownloadButton) {\r\n      this._createDownloadButton();\r\n    }\r\n    if (this._settingsService.settings.options.showMeasurementsButton) {\r\n      this._createMeasurementsButton();\r\n    }\r\n    if (this._settingsService.settings.options.development) {\r\n      this._createCameraSettingsButton();\r\n    }\r\n\r\n    const result: CustomFloorGroupResult = await this._loadIOneFurnitureFromSku(new Vector3(0, 0, 0), sku, undefined, true);\r\n    if (result && result.furniture) {\r\n      this._handleFirstBuildStandalone(result.furniture);\r\n    } else {\r\n      if (result.resultType === ResultType.NeedsUserInput) {\r\n        this._callBackFnWhenBuildFinished = this._handleFirstBuildStandalone;\r\n      }\r\n    }\r\n  }\r\n\r\n  private async _handleFirstBuildStandalone(item: Item): Promise<void> {\r\n    this._cameraService.moveCameraToFitObject(item);\r\n    if (this._settingsService.settings.options.cameraPositionFixed) {\r\n      this._rotationService.enableRotationFor(item);\r\n    } if (this._settingsService.settings.options.cameraPositionFixedAndScrollbar) {\r\n      this._cameraService.disableRotate();\r\n      this._cameraService.cameraZoomOut();\r\n      this._cameraService.disableZoom();\r\n    }\r\n    this._sceneService.needsRender = true;\r\n    this._callBackFnWhenBuildFinished = undefined;\r\n    if (this._settingsService.settings.cameraConfig) {\r\n      await this._dynamicCameraService.loadCustomCameraSettings();\r\n    }\r\n    if (this._settingsService.settings.options.enable3DInPhoto) {\r\n      this._threedInPhotoInitializerService.init(null, this._cameraService.camera, this._sceneService.scene, this._sceneService.renderer);\r\n    }\r\n\r\n    // save camera settings for render\r\n    this._cameraService.camera.updateMatrixWorld(true);\r\n    this._newRenderService.standAloneCameraMatrix = Array.from(this._cameraService.camera.matrixWorldInverse.elements);\r\n    this._buildFurnitureService.standAloneFirstBuildReady = true;\r\n    this._appEventService.readyToRender.next(true);\r\n  }\r\n\r\n  private _handleUndefinedErrorOccured(): void {\r\n    this.showSelections = false;\r\n    this.showAnswers = false;\r\n    this._buildFurnitureService.cancelConfiguringCurrentInstance();\r\n  }\r\n\r\n  private _removeButtons(): void {\r\n    this.editAddButtons.length = 0;\r\n    this.editCustomizeButton.length = 0;\r\n    this.resizeButtons.length = 0;\r\n  }\r\n\r\n  private _resetSelectedElement(): void {\r\n    this._selectedElementObject = undefined;\r\n    this._resetElementPosition();\r\n    this._removeAllButtons();\r\n    this.showElementToolbar = false;\r\n  }\r\n\r\n  private _handleRender(): void {\r\n    if (this._selectedElementObject || this.selectionToCustomize) {\r\n      this._resetElementPosition();\r\n      if (this.editAddButtons.length || this.editCustomizeButton.length > 0 || this.resizeButtons.length > 0) {\r\n        this._repositionButtons();\r\n      }\r\n    }\r\n  }\r\n\r\n  private _selectedElementToggle(element: Mesh): void {\r\n    this.selectedElement = element;\r\n    const obj: CustomObject3D = element ? element.parent as CustomObject3D : undefined;\r\n    if (this._selectedElementObject !== obj) {\r\n      this.showElementToolbar = false;\r\n      this._selectedElementObject = obj;\r\n      if (this.selectedElement) {\r\n        this._prepareElementMenu();\r\n        this._prepareAddButtons();\r\n        if (this._settingsService.settings.options.handleParametric) {\r\n          this._prepareOtherButtons();\r\n        }\r\n        const shouldBeHidden: boolean = obj.userData && obj.userData.selection && obj.userData.selection.question.indexOf('[hidden]') > -1;\r\n        if (this._settingsService.settings.options.instantReplace) {\r\n          if (shouldBeHidden) {\r\n            this.cancelElementReplace();\r\n          } else {\r\n            this.swapElement();\r\n          }\r\n        }\r\n        setTimeout(() => {\r\n          this.showElementToolbar = true;\r\n          this._sceneService.needsRender = true;\r\n        }, 200);\r\n      } else {\r\n        this._resetSelectedElement();\r\n      }\r\n    }\r\n  }\r\n\r\n  private _handleBuildFinished(result: CustomFloorGroupResult): void {\r\n    this._itemService.glassMaterialCheck(result.furniture);\r\n    if (this.selectedElement && result.furniture) {\r\n      const item: Item = result.furniture;\r\n      if (this.selectedElement instanceof CustomMesh) {\r\n        this._selectedElementObject = <CustomObject3D>this.selectedElement.parent;\r\n      }\r\n      this._prepareAddButtons();\r\n    }\r\n    if (this._callBackFnWhenBuildFinished && this.standAlone) {\r\n      this._callBackFnWhenBuildFinished(result.furniture);\r\n    }\r\n  }\r\n\r\n  private _resetElementPosition(): void {\r\n    if (this.selectedElement && !this.standAlone) {\r\n      const yPos: number = ((this.selectedElement.geometry.boundingBox.max.y - this.selectedElement.geometry.boundingBox.min.y) / 2);\r\n      const pos: Vector3 = new Vector3(0, 0, 0);\r\n      this.selectedElement.getWorldPosition(pos);\r\n      pos.y += yPos;\r\n      this.selectedElementPosition = this._sceneService.positionInSceneToScreen(pos);\r\n    } else {\r\n      this.selectedElementPosition = undefined;\r\n    }\r\n  }\r\n\r\n  private _removeAllButtons(): void {\r\n    this._removeAddButtons();\r\n    this._removeResizeButtons();\r\n    this._removeCustomButtons();\r\n  }\r\n\r\n  private _removeCustomButtons(): void {\r\n    this.editCustomizeButton.length = 0;\r\n  }\r\n\r\n  private _removeAddButtons(): void {\r\n    this.editAddButtons.length = 0;\r\n  }\r\n\r\n  private _removeResizeButtons(): void {\r\n    this.resizeButtons.length = 0;\r\n  }\r\n\r\n  private _removeEditItems(): void {\r\n    this.editElementMenu.length = 0;\r\n  }\r\n\r\n  private _prepareElementMenu(): void {\r\n    this._removeEditItems();\r\n    const selection: Selection = ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject);\r\n    if (this._settingsService.settings.options.showEditPencilConfigurator && selection) {\r\n      let options: Selection[] = this._getOptionsFromSelection(selection);\r\n      options = options.filter(o => {\r\n        return o.nodeType === 'OPT' && this._iOne.isSelectionPublished(o);\r\n      });\r\n      const len: number = options.length;\r\n      for (let i = 0; i < len; i++) {\r\n        this.editElementMenu.push(new CustomButton(options[i].question, () => {\r\n          this._buildFurnitureService.selectSelection(options[i], this.activeMetadata);\r\n          if (!this._settingsService.settings.options.instantEditMenu) {\r\n            this._resetSelectedElement();\r\n          }\r\n        }));\r\n      }\r\n    }\r\n  }\r\n\r\n  private async _afterLoadFromPreset(): Promise<void> {\r\n    this._loadingFromPreset = false;\r\n    this._progressService.finishDownloads();\r\n    if (this._itemsFromScratch.length > 0) {\r\n      for (let i = 0; i < this._itemsFromScratch.length; i++) {\r\n        await this._handleLoadAndBuildFurniture(\r\n          this._itemsFromScratch[i].metaData, false, false, false, false, true);\r\n      }\r\n      this._itemsFromScratch.length = 0;\r\n    }\r\n    if (this._itemsNeedUserInput.length > 0) {\r\n      for (let i = 0; i < this._itemsNeedUserInput.length; i++) {\r\n        const result: CustomFloorGroupResult = await this._handleLoadAndBuildFurniture(\r\n          this._itemsNeedUserInput[i].metaData, false, false, false, false, true);\r\n        this._loadFurnitureService.addToList(this._loadFurnitureService.objectList, result);\r\n      }\r\n      this._itemsNeedUserInput.length = 0;\r\n    }\r\n    if (\r\n      this._loadFurnitureService.objectListFixed.length > 0 ||\r\n      this._loadFurnitureService.obsoleteObjectCache.length > 0 ||\r\n      this._loadFurnitureService.notFixedObjectCache.length > 0 ||\r\n      this._loadFurnitureService.notLoaded.length > 0) {\r\n      this.setModelErrorDialog();\r\n    }\r\n  }\r\n\r\n  private _isIONEObject(o): boolean {\r\n    return !!o.item_schema || o.ione;\r\n  }\r\n\r\n  private _prepareAddButtons(): void {\r\n    const selection: Selection = ObjectUtils.GetSelectionFromSelectedObject(this._selectedElementObject);\r\n    this._removeAddButtons();\r\n    if (selection) {\r\n      // if (decoNode.gameObjectName.toLowerCase() === 'flat_r' ||\r\n      //   decoNode.gameObjectName.toLowerCase() === 'flat_l' ||\r\n      //   decoNode.gameObjectName.toLowerCase() === 'flat_d' ||\r\n      //   decoNode.gameObjectName.toLowerCase() === 'flat_u' ||\r\n      //   decoNode.gameObjectName.toLowerCase() === 'vert_r' ||\r\n      //   decoNode.gameObjectName.toLowerCase() === 'vert_l' ||\r\n      //   decoNode.gameObjectName.toLowerCase() === 'vert_d' ||\r\n      //   decoNode.gameObjectName.toLowerCase() === 'vert_u') {\r\n      //   if (decoNode.connectors) {\r\n      //     decoNode.connectors.forEach(c => c.linkedRepeatables = 'T');\r\n      //   }\r\n      // }\r\n      const len: number = selection.decoNode ? selection.decoNode.connectors.length : 0;\r\n      for (let i = 0; i < len; i++) {\r\n        let conObject: any = this._selectedElementObject.getObjectByName(selection.decoNode.connectors[i].connector);\r\n        if (!conObject && this._selectedElementObject.parent) {\r\n          conObject = this._selectedElementObject.parent.getObjectByName(selection.decoNode.connectors[i].connector);\r\n        }\r\n        if (conObject && this._canShowAddButton(selection.decoNode.connectors[i], conObject)) {\r\n          this.editAddButtons.push(new CustomButton('', () => {\r\n              this._handleAddButtonClick(selection, selection.decoNode.connectors[i], this._selectedElementObject);\r\n            },\r\n            conObject));\r\n        }\r\n      }\r\n    }\r\n    if (this.selectedElement) {\r\n      this._sceneService.scene.traverse((child) => {\r\n        if (child.name) {\r\n          const customizeButton: any = child.name.toLowerCase().startsWith('p_');\r\n          // const customizeOption: any = this._selectedElementObject.getObjectByName()\r\n          if (customizeButton) {\r\n            this.selectionToCustomize = child.parent;\r\n            this.editCustomizeButton.push(new CustomButton('', () => {\r\n                this.handleCustomizeClick();\r\n              },\r\n              this._selectedElementObject));\r\n          }\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  private _getOppositeConnectorParts(connector: string): string {\r\n    const connectorPartsArr: string[] = connector.split('_');\r\n    connectorPartsArr.pop(); // remove number\r\n    const connectorType: string = connectorPartsArr[connectorPartsArr.length - 1];\r\n    connectorPartsArr[connectorPartsArr.length - 1] = connectorType.toLowerCase() === 'f' ? 'M' : 'F';\r\n    return connectorPartsArr.join('_');\r\n  }\r\n\r\n  private _prepareOtherButtons(): void {\r\n    this._removeResizeButtons();\r\n    if (this._selectedElementObject) {\r\n      const parent: Item = ObjectUtils.GetParentItem(this._selectedElementObject);\r\n      if (parent) { // hide all connectors\r\n        parent.traverse(o => {\r\n          if (o.name && o.name.toLowerCase().startsWith('c_')) {\r\n            o.visible = false;\r\n          }\r\n        });\r\n      }\r\n      const otherConnectors: Mesh[] = <Mesh[]>this._selectedElementObject.children.filter(\r\n        c => c instanceof Mesh && (c.name && (c.name.toLowerCase().startsWith('c_sca_') || c.name.toLowerCase().startsWith('c_rep_'))));\r\n      otherConnectors.forEach(o => {\r\n        // o.visible = true\r\n        this.resizeButtons.push(new CustomButton('', () => {\r\n          this._handleResizeButtonClick(o.name, this._selectedElementObject);\r\n        }, o));\r\n      });\r\n    }\r\n  }\r\n\r\n  private _handleAddButtonClick(selection: Selection, connector: any, parent: Object3D): void {\r\n    let after: boolean;\r\n    if (connector.addAdjust === 2) {\r\n      after = connector.connector.indexOf('_M_') > -1;\r\n    }\r\n    this._buildFurnitureService.baseElementNodeId = parent.userData && parent.userData.selection ? parent.userData.selection.nodeId : 0;\r\n    this._buildFurnitureService.activeConnector = connector;\r\n    this._buildFurnitureService.selectSelection(\r\n      selection, this.activeMetadata, connector.linkedRepeatables !== 'T', after, connector.connector);\r\n    this._resetSelectedElement();\r\n  }\r\n\r\n  private _handleResizeButtonClick(connector: any, parent: Object3D): void {\r\n    this._resizeService.resizeElement(connector, parent);\r\n  }\r\n\r\n  private _canShowAddButton(connector: any, conObject: any): boolean {\r\n    return (!conObject.connected || connector.linkedRepeatables === 'T');\r\n  }\r\n\r\n  private _repositionButtons(): void {\r\n    const len: number = this.editAddButtons.length;\r\n    for (let i: number = 0; i < len; i++) {\r\n      this._repositionButton(this.editAddButtons[i]);\r\n    }\r\n    const lenr: number = this.resizeButtons.length;\r\n    for (let r: number = 0; r < lenr; r++) {\r\n      this._repositionButton(this.resizeButtons[r]);\r\n    }\r\n    const lenc: number = this.editCustomizeButton.length;\r\n    for (let c: number = 0; c < lenc; c++) {\r\n      this._repositionButton(this.editCustomizeButton[c]);\r\n    }\r\n  }\r\n\r\n  private _repositionButton(button: CustomButton): void {\r\n    const pos: Vector3 = new Vector3(0, 0, 0);\r\n    button.data.getWorldPosition(pos);\r\n    const screenPos: Vector2 = this._sceneService.positionInSceneToScreen(pos);\r\n    button.xPos = screenPos.x;\r\n    button.yPos = screenPos.y;\r\n    const distanceToCam: number = this._cameraService.camera.position.distanceTo(pos);\r\n    button.size = (4 / distanceToCam) * 30;\r\n    button.opacity = Math.max(0.25, 1 - (Math.max(7.0, (Math.round(distanceToCam * 10) / 10)) - 7));\r\n  }\r\n\r\n  private _getOptionsFromSelection(baseSelection: Selection): Selection[] {\r\n    return this._buildFurnitureService.getOptionsFromSelection(baseSelection);\r\n  }\r\n\r\n  private _handleAnswerCountReceived(answerCount: number): void {\r\n    this.showAnswers = answerCount > 0;\r\n    if (this.showAnswers) {\r\n      this.showLiteSelector = !this._loadingFromPreset;\r\n    }/* else {\r\n      if (this._initialStartup) {\r\n        // this._iOne.loadSelections();\r\n        this._initialStartup = false;\r\n      }\r\n    }*/\r\n  }\r\n\r\n  private async _handleLoadIOneFurnitureIntoSceneBySKU(sku: string, settings: ExternalSettingsInterface, position: { x: number, y: number, z?: number }): Promise<void> {\r\n    const toast = new Toast();\r\n    toast.message = 'MODEL_LOADING';\r\n    this._toastService.showToast(toast);\r\n    await this._connectorAdapterService.initConnector(\r\n        settings ? settings.settings : this._settingsService.settings,\r\n        settings ? settings.name : undefined,\r\n      false,\r\n      settings ? settings.externalSourceId : undefined);\r\n    const article: Article = await this._loadFurnitureService.loadArticle(sku);\r\n    const draggedData: DraggedData = {\r\n      name: sku,\r\n      constructFn: async (pos) => this._loadIOneFurnitureFromSku(pos, sku, settings),\r\n      type: itemTypeFromPlacement(article.placement),\r\n      iOne: true\r\n    };\r\n    this._messageBus.emit(MessageType.SetDrag, draggedData);\r\n    this._messageBus.emit(MessageType.StartDrag, position);\r\n  }\r\n\r\n  private async _handleCopyIOneFurnitureIntoSceneBySKU(original: Item): Promise<void> {\r\n    const toast = new Toast();\r\n    toast.message = 'MODEL_LOADING';\r\n    this._toastService.showToast(toast);\r\n    original.metadata.conversionGTMSend = false;\r\n    const draggedData = {\r\n      name: original.metadata.itemIdentifier,\r\n      constructFn: (pos) => this._loadIOneFurnitureFromOriginal(original.metadata, pos, original.rotation),\r\n      type: original.metadata.itemType,\r\n      iOne: true\r\n    };\r\n    this._messageBus.emit(MessageType.SetDrag, draggedData);\r\n    this._messageBus.emit(MessageType.StartDrag, original.position);\r\n  }\r\n\r\n  private async _loadIOneFurnitureFromOriginal(md: Metadata, pos: Vector3, rot: Euler): Promise<CustomFloorGroupResult> {\r\n    const newMetaData = {...md};\r\n    newMetaData.rotation = new Euler().copy(rot);\r\n    return this._handleLoadAndBuildFurniture(newMetaData, true, false, false, false, false);\r\n  }\r\n\r\n  private _loadIOneFurnitureFromSku(\r\n    pos: Vector3, sku: string, settings?: ExternalSettingsInterface, standAlone: boolean = false): Promise<CustomFloorGroupResult> {\r\n    const md: Metadata = {\r\n      position: pos,\r\n      itemIdentifier: sku,\r\n      externalSettings: settings\r\n    };\r\n    return this._handleLoadAndBuildFurniture(md, false, true, false, standAlone, false);\r\n  }\r\n\r\n  private async _handleCopyInstanceForFurniture(furniture: Item[]): Promise<void> {\r\n    const len: number = furniture.length;\r\n    for (let i = 0; i < len; i++) {\r\n      const customItem: Item = furniture[i];\r\n      if (customItem.metadata && customItem.metadata.itemId) {\r\n        const oldInstance: string = customItem.metadata.itemId;\r\n        const newInstance: string = await this._iOne.copyInstanceAndSaveOriginalConfiguration(oldInstance, null);\r\n        customItem.metadata.itemId = newInstance;\r\n        customItem.userData.itemId = newInstance;\r\n        customItem.metadata.originalItemId = oldInstance;\r\n      }\r\n    }\r\n  }\r\n\r\n  private async _handleLoadIOneFurnitureFromPreset(furniture): Promise<void> {\r\n    const externalSources: ExternalSource[] = [];\r\n    const catalogData: CatalogDefinition[] = await this._connectorAdapterService.getCatalogDefinitionsList();\r\n    if (catalogData) {\r\n      for (const catalogItem of catalogData) {\r\n        if (catalogItem.externalSourceId !== null) {\r\n          const externalData: ExternalSource = await this._connectorAdapterService.getExternalSource(catalogItem.externalSourceId);\r\n          if (externalData) {\r\n            externalSources.push(externalData);\r\n          }\r\n\r\n        }\r\n      }\r\n    }\r\n    const len: number = furniture.length;\r\n    for (let i: number = 0; i < len; i++) {\r\n      if (furniture[i].externalSettings && furniture[i].externalSettings.externalSourceId === undefined) {\r\n        const externalSourceObj: ExternalSource =\r\n          externalSources.find(source => source.schema === furniture[i].externalSettings.settings.schema);\r\n        if (externalSourceObj && externalSourceObj.schema !== '') {\r\n          if (furniture[i].externalSettings.settings['username'] !== undefined && furniture[i].externalSettings.settings['password'] !== undefined) {\r\n            furniture[i].externalSettings.settings['username'] = '';\r\n            furniture[i].externalSettings.settings['password'] = '';\r\n          }\r\n          furniture[i].externalSettings.externalSourceId = externalSourceObj.sourceId;\r\n        } else {\r\n          console.log('source not available');\r\n        }\r\n      }\r\n      await this._loadFurnitureFromItem(furniture[i]);\r\n    }\r\n    this._messageBus.emit(MessageType.ShouldCopyFurnitureFromPreset, true);\r\n  }\r\n\r\n  private async _loadFurnitureFromItem(item: any): Promise<CustomFloorGroupResult> {\r\n    const position = new Vector3(\r\n      item.xpos, item.ypos, item.zpos);\r\n    const metadata = {\r\n      itemName: item.item_name,\r\n      itemDescription: item.item_description,\r\n      itemId: item.item_id,\r\n      itemIdentifier: item.item_identifier,\r\n      configurable: !isNill(item.configurable) ? item.configurable : true,\r\n      ione: item.ione,\r\n      schema: item.item_schema,\r\n      resizable: item.resizable,\r\n      elevation: item.elevation,\r\n      elevationFixed: item.elevationFixed,\r\n      elevationAdjustable: item.elevationAdjustable,\r\n      itemType: item.item_type,\r\n      modelUrl: item.model_url,\r\n      texture: item.texture,\r\n      position: position,\r\n      rotation: new Euler(0, item.rotation, 0),\r\n      scale: item.scale,\r\n      centerPivot: true,\r\n      ignoreInvisible: item.ignoreInvisible,\r\n      updatePivotOnCreate: true,\r\n      opening: item.opening,\r\n      locked: item.locked,\r\n      itemGroup: item.itemGroup,\r\n      decos: item.decos,\r\n      selections: item.selections,\r\n      elementConfiguration: item.elementConfiguration,\r\n      onWall: item.onWall,\r\n      externalSettings: item.externalSettings,\r\n      conversionGTMSend: item.conversionGTMSend,\r\n      conversionSubmittedPrice: item.conversionSubmittedPrice\r\n    };\r\n    return this._handleLoadAndBuildFurniture(\r\n      metadata, true, true, true, false, true, false);\r\n  }\r\n\r\n  private async _handleLoadAndBuildFurniture(\r\n    furnitureData: Metadata,\r\n    shouldCopyInstance: boolean,\r\n    looseOriginalConfiguration: boolean,\r\n    fromPreset: boolean,\r\n    standAlone: boolean,\r\n    fromScratch: boolean,\r\n    showErrorDialog: boolean = true,\r\n  ): Promise<CustomFloorGroupResult> {\r\n    await this._connectorAdapterService.initConnector(\r\n        furnitureData.externalSettings ? furnitureData.externalSettings.settings : this._settingsService.settings,\r\n        furnitureData.externalSettings ? furnitureData.externalSettings.name : undefined,\r\n        false,\r\n        furnitureData.externalSettings ? furnitureData.externalSettings.externalSourceId : null\r\n    );\r\n\r\n    const result: CustomFloorGroupResult =\r\n      await this._loadFurnitureService.loadFurniture(\r\n        furnitureData, shouldCopyInstance, looseOriginalConfiguration, standAlone, fromScratch, fromPreset)\r\n        .catch((errorResult: CustomFloorGroupResult) => {\r\n          if ((typeof errorResult === 'string' && errorResult === 'ECONNABORTED') ||\r\n            errorResult.resultType === ResultType.Timeout ) { // timeout\r\n            errorResult = new CustomFloorGroupResult(furnitureData.itemIdentifier, furnitureData.itemName);\r\n            errorResult.errorMessages.push(new ErrorMessage('TIMEOUT'));\r\n            errorResult.resultType = ResultType.Timeout;\r\n          }\r\n          this._messageBus.emit(MessageType.FinishedIOneFurnitureBuild);\r\n          this._handleError(errorResult, showErrorDialog);\r\n          return errorResult;\r\n        });\r\n    this._messageBus.emit(MessageType.FinishedIOneFurnitureBuild);\r\n    if (result) {\r\n      if (result.resultType === ResultType.BuildFromScratch) {\r\n        if (fromPreset) { // start configuring when loading is done\r\n          result.metaData = {...furnitureData};\r\n          this._itemsFromScratch.push(result);\r\n        } else {\r\n          furnitureData.position = this._floorplanService.getCenter();\r\n          if (!standAlone) {\r\n            this._dialogService.showDialog({\r\n              data: {\r\n                type: DialogType.Warning,\r\n                title: this._dictionaryService.get('BUILD_PRODUCT_FROM_SCRATCH'),\r\n                messages: [{message: this._dictionaryService.get('MODEL_HAS_NO_DEFAULTS')}]\r\n              }\r\n            });\r\n            return this._handleLoadAndBuildFurniture(furnitureData, false, true, fromPreset, standAlone, true);\r\n          } else {\r\n            this.activeMetadata = result ? result.metaData : null;\r\n            return result;\r\n          }\r\n        }\r\n      }\r\n      if (result.resultType === ResultType.NeedsUserInput) {\r\n        result.metaData = {...furnitureData};\r\n        if (fromPreset) { // start configuring when loading is done\r\n          this._itemsNeedUserInput.push(result);\r\n        } else {\r\n          result.metaData.position = this._floorplanService.getCenter();\r\n        }\r\n      }\r\n      if (result.resultType === ResultType.ExternalSourceNotAvailable) {\r\n        this._loadFurnitureService.addToList(this._loadFurnitureService.externalSourceNotAvailable, result);\r\n      }\r\n      if (result.furniture) {\r\n        if (shouldCopyInstance) {\r\n          const closestWallEdge: HalfEdge = this._roomService.getClosestWallEdge(result.furniture.position.x, result.furniture.position.z);\r\n          if (result.furniture instanceof CustomWallFloorItem && result.furniture.onWall) {\r\n            (result.furniture as CustomWallFloorItem).placeOnEdge(closestWallEdge);\r\n            result.furniture.moveFromFloorToWall();\r\n          } else if (result.furniture instanceof WallItem && !(result.furniture instanceof CustomWallFloorItem)) {\r\n            (result.furniture as WallItem).placeOnEdge(closestWallEdge);\r\n          }\r\n        }\r\n        if (result.furniture instanceof CustomWallItem && standAlone) {\r\n          result.furniture.position.y += result.furniture.halfSize.y;\r\n        }\r\n        if (result.resultType === ResultType.Obsolete) {\r\n          this._loadFurnitureService.addToList(this._loadFurnitureService.obsoleteObjectCache, result);\r\n        }\r\n        if (result.resultType === ResultType.Loaded) {\r\n          if (result.metaData.configurable) {\r\n            this._loadFurnitureService.addToList(this._loadFurnitureService.objectList, result);\r\n          } else {\r\n            this._loadFurnitureService.addToList(this._loadFurnitureService.simpleObjectList, result);\r\n          }\r\n        }\r\n        if (result.resultType === ResultType.ConfigurationFixed) {\r\n          this._loadFurnitureService.addToList(this._loadFurnitureService.objectListFixed, result);\r\n        }\r\n\r\n        this._addToSceneGTM(result.furniture);\r\n      }\r\n    }\r\n    if (!fromPreset) {\r\n      this._progressService.finishDownloads();\r\n    }\r\n    this.activeMetadata = result ? result.metaData : null;\r\n    this._sceneService.needsRender = true;\r\n    return result;\r\n  }\r\n\r\n  private _answerSelected(result: CustomFloorGroupResult): void {\r\n    this._loadFurnitureService.addToList(this._loadFurnitureService.objectList, result);\r\n  }\r\n\r\n  private _handleError(error: CustomFloorGroupResult, showDialog: boolean): void {\r\n    if (error.instanceId || error.sku) {\r\n      switch (error.resultType) {\r\n        case ResultType.ArticleNotFound:\r\n        case ResultType.Timeout:\r\n        case ResultType.ConfigurationNotFixed:\r\n        case ResultType.GameobjectNameMismatchInSource:\r\n        case ResultType.NoSelections:\r\n        case ResultType.NoDecoNodes:\r\n        case ResultType.ExternalSourceNotAvailable:\r\n          this._loadFurnitureService.notLoaded.push(error);\r\n          if (showDialog) {\r\n            this._showWarning({title: 'ERROR', messages: error.errorMessages});\r\n          }\r\n          break;\r\n        default:\r\n          this._loadFurnitureService.notLoaded.push(error);\r\n          if (showDialog) {\r\n            this._showWarning({title: 'ERROR', messages: [new ErrorMessage('ERROR_LOADING_FURNITURE')]});\r\n          }\r\n      }\r\n    } else {\r\n      if (showDialog) {\r\n        this._showWarning({title: 'ERROR', messages: [new ErrorMessage('ERROR_LOADING_FURNITURE')]});\r\n      }\r\n    }\r\n    this._messageBus.emit(MessageType.UndefinedErrorOccured);\r\n  }\r\n\r\n  private async _handleConfigureModeChange(configuringModeChange: ConfiguringModeChangeInterface): Promise<void> {\r\n    if (this.standAlone) {\r\n      return;\r\n    }\r\n    if (configuringModeChange.configuring) {\r\n      this._iOne.emptySelections();\r\n      this._appStateService.undoDisabled = true;\r\n      this._appStateService.redoDisabled = true;\r\n      this.activeMetadata = configuringModeChange.metadata;\r\n      this._handleLoadAndBuildFurniture(\r\n        configuringModeChange.metadata, false, false, false, false, false);\r\n    } else {\r\n      this._appStateService.undoDisabled = false;\r\n      this._appStateService.redoDisabled = false;\r\n    }\r\n    this.showAnswers = false;\r\n    this.showSelections = configuringModeChange.configuring || this.standAlone;\r\n    this.showLiteSelector = configuringModeChange.configuring || this.standAlone;\r\n  }\r\n\r\n  private _addModelDialogToolbar(): void {\r\n    this._messageService.emit(MessageType.RegisterToolbarIcon, {\r\n      template: this.toolbarIconModels,\r\n      position: 'top',\r\n      priority: 800\r\n    });\r\n  }\r\n\r\n  private _showWarning(config: DialogConfig) {\r\n    this._dialogService.showDialog({data: config});\r\n  }\r\n\r\n  private async _addToSceneGTM(furniture: Item): Promise<void> {\r\n    if (furniture && furniture.metadata) {\r\n      const goodId: number = await this._connectorAdapterService.getGoodIdFromArticleNr(furniture.metadata.itemIdentifier);\r\n      const articleFullObject = await this._connectorAdapterService.getArticleFullObject(goodId);\r\n      let articleCategories: ArticleCategory[];\r\n      if (articleFullObject && articleFullObject.publication !== undefined) {\r\n        articleCategories = await this._connectorAdapterService.getArticleCategories(articleFullObject.publication);\r\n      }\r\n\r\n      let data = {\r\n        'articleNr': furniture.metadata.itemIdentifier,\r\n        'product': furniture.metadata.itemName,\r\n        'schema': furniture.metadata.schema\r\n      };\r\n      if (furniture.metadata.externalSettings !== undefined) {\r\n        const externalData = {\r\n          'externalSourceName': furniture.metadata.externalSettings.name,\r\n          'externalSourceUrl': furniture.metadata.externalSettings.settings.url\r\n        };\r\n        data = {...data, ...externalData};\r\n      }\r\n      if (articleFullObject) {\r\n        const articleData = {\r\n          'brandId': articleFullObject.brandId,\r\n          'retailFormulas': articleFullObject.retailFormulas,\r\n          'turnOverGroup': articleFullObject.turnOverGroup\r\n        };\r\n        data = {...data, ...articleData};\r\n      }\r\n      if (articleCategories) {\r\n        const categoryList = [];\r\n        for (const category of articleCategories) {\r\n          if (category.description) {\r\n            categoryList.push(category.description);\r\n          }\r\n        }\r\n        const categoryData = {\r\n          'categories': categoryList\r\n        };\r\n        data = {...data, ...categoryData};\r\n      }\r\n      this._googleTagManager.sendEvent(GoogleTagManagerEvent.AddToScene, data);\r\n    }\r\n  }\r\n}\r\n","<rp-lite-selector *ngIf=\"!standAlone\" class=\"floating\"\r\n                  [(show)]=\"showLiteSelector\"\r\n                  [metadata]=\"activeMetadata\"\r\n                  [showSelections]=\"showSelections\"\r\n                  [showAnswers]=\"showAnswers\"\r\n                  (showChange)=\"handleShowChangeSelector($event)\"\r\n></rp-lite-selector>\r\n<ng-container *ngIf=\"showElementToolbar\">\r\n  <rp-element-toolbar class=\"rp-element-toolbar floating\" [class.custom]=\"standAlone\" @showElementToolbar\r\n                      [editMenu]=\"editElementMenu\"\r\n                      [showSwap]=\"showSwapButton\"\r\n                      [showPointer]=\"selectedElementPosition !== undefined\"\r\n                      (swapClicked)=\"swapElement()\"\r\n                      (deleteClicked)=\"deleteElement()\"\r\n                      (animationClicked)=\"openAnimationSidebar()\"\r\n  ></rp-element-toolbar>\r\n  <rp-element-buttons class=\"rp-element-buttons floating\" @showElementToolbar\r\n                      [elementPointer]=\"elementToolbar?.elementPointer\"\r\n                      [addButtons]=\"editAddButtons\"\r\n                      [customizeButtons]=\"editCustomizeButton\"\r\n                      [resizeButtons]=\"resizeButtons\"\r\n                      [elementPosition]=\"selectedElementPosition\"\r\n                      (customizeButtonClicked)=\"handleCustomizeClick()\"\r\n  ></rp-element-buttons>\r\n</ng-container>\r\n\r\n<ng-container *ngIf=\"showCustomizeButtons\">\r\n  <rp-element-buttons class=\"rp-element-buttons floating\"\r\n                      [elementPointer]=\"elementToolbar?.elementPointer\"\r\n                      [customizeButtons]=\"editCustomizeButton\"\r\n                      [elementPosition]=\"selectedElementPosition\"\r\n                      (customizeButtonClicked)=\"handleCustomizeClick()\"\r\n  ></rp-element-buttons>\r\n</ng-container>\r\n\r\n<ng-template #toolbarIconModels>\r\n  <rp-toolbar-icon\r\n    matIcon=\"format_list_bulleted\"\r\n    tooltip=\"{{iconName.Objects | localize}}\"\r\n    (onClick)=\"setModelErrorDialog()\"\r\n    [showLabel]=\"shouldShowLabel\"\r\n  ></rp-toolbar-icon>\r\n</ng-template>\r\n\r\n<ng-template #selectedThreedObjectAnimationSidebar>\r\n  <header class=\"drawer__header\">\r\n    <h2 class=\"mat-title\" [textContent]=\"'ANIMATE' | localize\"></h2>\r\n  </header>\r\n  <rp-animation>\r\n\r\n  </rp-animation>\r\n</ng-template>\r\n\r\n<ng-template #selectedThreedObjectCustomizationSidebar>\r\n  <header class=\"drawer__header\">\r\n    <h2 class=\"mat-title\" [textContent]=\"'CUSTOMIZE' | localize\"></h2>\r\n  </header>\r\n  <rp-customizer\r\n    [selection]=\"selectionToCustomize\"\r\n  ></rp-customizer>\r\n</ng-template>\r\n\r\n<div class=\"slider-container\">\r\n  <rp-element-slider class=\"rp-element-slider\"></rp-element-slider>\r\n</div>\r\n"]}