awv3/session/selector.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.Selector = undefined;

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _object = require('../three/object3');

var _object2 = _interopRequireDefault(_object);

var _materialselector = require('./materialselector');

var _objectselector = require('./objectselector');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @class Selector activates/deactivates selection for selection-elements in the UI.
 * Creates a new interaction using the type-filter provided with the selection-element.
 * Forwards events to the current selector (material- or object-selector). Provides
 * functions to access selected ids and elements as well as to check if a certain
 * element is already selected. Selected elements can be materials or objects.
 * Activation/deactivation is triggered by observing the state of state.globals.activeSelection.
 */
var Selector = exports.Selector = function () {
    function Selector(session, options) {
        var _this = this;

        (0, _classCallCheck3.default)(this, Selector);

        this.options = (0, _extends3.default)({}, options);

        this.session = session;
        // Wait until the sessions pool has been added into the view (happens in <App/>)
        this.session.pool.viewFound().then(function (view) {
            return _this.view = view;
        });

        // the current selector
        this.currentSelector = undefined;
        this.objectSelector = new _objectselector.ObjectSelector(session);
        this.materialSelector = new _materialselector.MaterialSelector(session);

        // store the element for activation/deactivation purposes
        this.element = undefined;

        // observe when a selection-element is activated
        this.session.observe(function (state) {
            return state.globals.activeSelection;
        }, function (id) {
            if (id !== undefined) {
                var element = _this.session.elements[id]; //session stores all elements in hashmap
                // Deactivate previous element/selector
                if (_this.element && _this.element !== element) {
                    _this.deactivate();
                }
                // activate new element
                if (element.types && element.types.indexOf('Object') > -1) {
                    _this.currentSelector = _this.objectSelector;
                } else {
                    _this.currentSelector = _this.materialSelector;
                }
                _this.activate(element);
            } else {
                _this.deactivate();
            }
        });
    }

    /**
     * Deactivates the selection.
     */


    (0, _createClass3.default)(Selector, [{
        key: 'deactivate',
        value: function deactivate() {
            this.session.pool.scene.removeInteraction();
            this.view.interaction.filter = undefined;
            this.view.setCursor();

            this.currentSelector.deactivate();
            this.element = undefined;
        }

        /**
         * Activates the selection for the given selection-element. Creates an interaction
         * based on the element's type-filter.
         */

    }, {
        key: 'activate',
        value: function activate(element) {
            var _this2 = this,
                _session$pool$scene$c;

            this.element = element;
            this.currentSelector.activate(element);
            this.view.interaction.filter = [this.session.pool.scene];

            var types = ['Scene'];
            if (Array.isArray(element.types)) types = [].concat((0, _toConsumableArray3.default)(types), (0, _toConsumableArray3.default)(element.types));else if (typeof element.types === 'function') types = function types(object) {
                return object.type === 'Scene' || element.types(object);
            };

            // Interaction on pool
            this.session.pool.scene.createInteraction({ recursive: true, types: types }).on((_session$pool$scene$c = {}, (0, _defineProperty3.default)(_session$pool$scene$c, _object2.default.Events.Interaction.Hovered, function (event) {
                _this2.currentSelector.hover(event);
            }), (0, _defineProperty3.default)(_session$pool$scene$c, _object2.default.Events.Interaction.Unhovered, function (event) {
                _this2.currentSelector.unhover(event);
            }), (0, _defineProperty3.default)(_session$pool$scene$c, _object2.default.Events.Interaction.Clicked, function (event) {
                _this2.currentSelector.clicked(event);
            }), (0, _defineProperty3.default)(_session$pool$scene$c, _object2.default.Events.Interaction.Missed, function (event) {
                _this2.currentSelector.missed(event);
            }), (0, _defineProperty3.default)(_session$pool$scene$c, _object2.default.Events.Lifecycle.Rendered, function () {
                _this2.currentSelector.rendered(event);
            }), _session$pool$scene$c));
        }

        /**
         * Check if element is already selected
         * @return {bool} TRUE if selected, FALSE otherwise
         */

    }, {
        key: 'isSelected',
        value: function isSelected(element) {
            return this.currentSelector ? this.currentSelector.isSelected(element) : false;
        }

        /**
         * Returns the selected ids in an array
         * @return {array} selectedIds - Array with the selected ids
         */

    }, {
        key: 'getSelectedIds',
        value: function getSelectedIds() {
            return this.currentSelector ? this.currentSelector.getSelectedIds() : [];
        }

        /**
         * Returns the selected elements in an array
         * @return {array} selectedElements - Array with the selected elements
         */

    }, {
        key: 'getSelectedElements',
        value: function getSelectedElements() {
            return this.currentSelector ? this.currentSelector.getSelectedElements() : [];
        }

        /**
         * Removes the given elements from the current selection.
         * @param {array} elements - elements to be removed from the selection.
         */

    }, {
        key: 'unselectElements',
        value: function unselectElements(elements) {
            this.currentSelector && this.currentSelector.unselectElements(elements);
        }
    }]);
    return Selector;
}();