ole/build/editor.js

OpenLayers Editor

import Collection from 'ol/Collection';
import Toolbar from './control/toolbar';
/**
 * Core component of OLE.
 * All controls are added to this class.
 */
class Editor {
    /**
     * Initialization of the editor.
     * @param {ol.Map} map The map object.
     * @param {Object} [options] Editor options.
     * @param {Boolean} [options.showToolbar] Whether to show the toolbar.
     * @param {HTMLElement} [options.target] Specify a target if you want
     *   the toolbar to be rendered outside of the map's viewport.
     */
    constructor(map, opts) {
        /**
         * @private
         * @type {ol.Map}
         */
        this.map = map;
        /**
         * @private
         * @type {ol.Collection<ole.Control>}
         */
        this.controls = new Collection();
        /**
         * @private
         * @type {ol.Collection<ole.Control>}
         */
        this.activeControls = new Collection();
        /**
         * @private
         * @type {ol.Collection<ole.Service>}
         */
        this.services = new Collection();
        /**
         * @private
         * @type {Object}
         */
        this.options = opts || {};
        /**
         * Feature that is currently edited.
         * @private
         * @type {ol.Feature}
         */
        this.editFeature = null;
        if (typeof this.options.showToolbar === 'undefined') {
            this.options.showToolbar = true;
        }
        if (this.options.showToolbar) {
            this.toolbar = new Toolbar(this.map, this.controls, this.options.target);
        }
        this.activeStateChange = this.activeStateChange.bind(this);
    }
    /**
     * Adds a new control to the editor.
     * @param {ole.Control} control The control.
     */
    addControl(control) {
        control.setMap(this.map);
        control.setEditor(this);
        control.addEventListener('change:active', this.activeStateChange);
        this.controls.push(control);
    }
    /**
     * Remove a control from the editor
     * @param {ole.Control} control The control.
     */
    removeControl(control) {
        control.deactivate();
        this.controls.remove(control);
        control.removeEventListener('change:active', this.activeStateChange);
        control.setEditor();
        control.setMap();
    }
    /**
     * Adds a service to the editor.
     */
    addService(service) {
        service.setMap(this.map);
        service.setEditor(this);
        service.activate();
        this.services.push(service);
    }
    /**
     * Adds a collection of controls to the editor.
     * @param {ol.Collection<ole.Control>} controls Collection of controls.
     */
    addControls(controls) {
        const ctrls = controls instanceof Collection ? controls : new Collection(controls);
        for (let i = 0; i < ctrls.getLength(); i += 1) {
            this.addControl(ctrls.item(i));
        }
    }
    /**
     * Removes the editor from the map.
     */
    remove() {
        const controls = [...this.controls.getArray()];
        controls.forEach((control) => {
            this.removeControl(control);
        });
        if (this.toolbar) {
            this.toolbar.destroy();
        }
    }
    /**
     * Returns a list of ctive controls.
     * @returns {ol.Collection.<ole.Control>} Active controls.
     */
    getControls() {
        return this.controls;
    }
    /**
     * Returns a list of active controls.
     * @returns {ol.Collection.<ole.Control>} Active controls.
     */
    getActiveControls() {
        return this.activeControls;
    }
    /**
     * Sets an instance of the feature that is edited.
     * Some controls need information about the feature
     * that is currently edited (e.g. for not snapping on them).
     * @param {ol.Feature|null} feature The editfeature (or null if none)
     * @protected
     */
    setEditFeature(feature) {
        this.editFeature = feature;
    }
    /**
     * Returns the feature that is currently edited.
     * @returns {ol.Feature|null} The edit feature.
     */
    getEditFeature() {
        return this.editFeature;
    }
    /**
     * Sets an instance of the feature that is being drawn.
     * Some controls need information about the feature
     * that is currently being drawn (e.g. for not snapping on them).
     * @param {ol.Feature|null} feature The drawFeature (or null if none).
     * @protected
     */
    setDrawFeature(feature) {
        this.drawFeature = feature;
    }
    /**
     * Returns the feature that is currently being drawn.
     * @returns {ol.Feature|null} The drawFeature.
     */
    getDrawFeature() {
        return this.drawFeature;
    }
    /**
     * Controls use this function for triggering activity state changes.
     * @param {ol.control.Control} control Control.
     * @private
     */
    activeStateChange(evt) {
        const ctrl = evt.detail.control;
        // Deactivate other controls that are not standalone
        if (ctrl.getActive() && ctrl.standalone) {
            for (let i = 0; i < this.controls.getLength(); i += 1) {
                const otherCtrl = this.controls.item(i);
                if (otherCtrl !== ctrl &&
                    otherCtrl.getActive() &&
                    otherCtrl.standalone) {
                    otherCtrl.deactivate();
                    this.activeControls.remove(otherCtrl);
                }
            }
        }
        if (ctrl.getActive()) {
            this.activeControls.push(ctrl);
        }
        else {
            this.activeControls.remove(ctrl);
        }
    }
}
export default Editor;