@igo2/geo 1.12.1 → 1.13.0-alpha.0

package/esm2020/lib/measure/measurer/measurer.component.mjs

@@ -0,0 +1,1042 @@
+import { Component, Input, ChangeDetectionStrategy, ViewChild } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { skip } from 'rxjs/operators';
+import OlStyle from 'ol/style/Style';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import OlVectorSource from 'ol/source/Vector';
+import { unByKey } from 'ol/Observable';
+import { StorageScope } from '@igo2/core';
+import { uuid } from '@igo2/utils';
+import { FeatureDataSource } from '../../datasource';
+import { FEATURE, FeatureStoreLoadingStrategy, FeatureStoreSelectionStrategy, tryBindStoreLayer, tryAddLoadingStrategy, tryAddSelectionStrategy } from '../../feature';
+import { DrawControl, ModifyControl } from '../../geometry/shared';
+import { VectorLayer } from '../../layer';
+import { MeasureType, MeasureAreaUnit, MeasureLengthUnit, } from '../shared/measure.enum';
+import { measureOlGeometry, createMeasureInteractionStyle, createMeasureLayerStyle, updateOlTooltipsAtMidpoints, updateOlTooltipAtCenter, getTooltipsOfOlGeometry, squareMetersToUnit, metersToUnit, formatMeasure } from '../shared/measure.utils';
+import { MeasurerDialogComponent } from './measurer-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "@angular/material/dialog";
+const _c0 = ["table"];
+function MeasurerComponent_mat_divider_13_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_mat_slide_toggle_15_Template(rf, ctx) { if (rf & 1) {
+    const _r12 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 7);
+    i0.ɵɵlistener("change", function MeasurerComponent_mat_slide_toggle_15_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r12); const ctx_r11 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r11.onToggleDisplayLines($event.checked)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("checked", ctx_r1.displayLines)("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 3, "igo.geo.measure.toggleDisplayLines"), " ");
+} }
+function MeasurerComponent_mat_divider_17_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_mat_slide_toggle_20_Template(rf, ctx) { if (rf & 1) {
+    const _r14 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 7);
+    i0.ɵɵlistener("change", function MeasurerComponent_mat_slide_toggle_20_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r13 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r13.onToggleDisplayDistance($event.checked)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("checked", ctx_r3.displayDistance)("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 3, "igo.geo.measure.toggleDisplayDistance"), " ");
+} }
+function MeasurerComponent_mat_slide_toggle_22_Template(rf, ctx) { if (rf & 1) {
+    const _r16 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 7);
+    i0.ɵɵlistener("change", function MeasurerComponent_mat_slide_toggle_22_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r16); const ctx_r15 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r15.onToggleDisplayAreas($event.checked)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r4 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("checked", ctx_r4.displayAreas)("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 3, "igo.geo.measure.toggleDisplayAreas"), " ");
+} }
+function MeasurerComponent_mat_divider_24_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_ng_container_29_igo_measurer_item_1_Template(rf, ctx) { if (rf & 1) {
+    const _r21 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "igo-measurer-item", 14);
+    i0.ɵɵlistener("measureUnitChange", function MeasurerComponent_ng_container_29_igo_measurer_item_1_Template_igo_measurer_item_measureUnitChange_0_listener($event) { i0.ɵɵrestoreView(_r21); const ctx_r20 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r20.onLengthUnitChange($event)); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const measure_r17 = i0.ɵɵnextContext().ngIf;
+    const ctx_r18 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("measureType", ctx_r18.measureType.Length)("measureUnit", ctx_r18.measureLengthUnit.Meters)("measure", measure_r17.length)("auto", ctx_r18.measureUnitsAuto)("placeholder", i0.ɵɵpipeBind1(1, 5, ctx_r18.activeMeasureType === ctx_r18.measureType.Area ? "igo.geo.measure.perimeter" : "igo.geo.measure.length"));
+} }
+function MeasurerComponent_ng_container_29_igo_measurer_item_2_Template(rf, ctx) { if (rf & 1) {
+    const _r24 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "igo-measurer-item", 14);
+    i0.ɵɵlistener("measureUnitChange", function MeasurerComponent_ng_container_29_igo_measurer_item_2_Template_igo_measurer_item_measureUnitChange_0_listener($event) { i0.ɵɵrestoreView(_r24); const ctx_r23 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r23.onAreaUnitChange($event)); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const measure_r17 = i0.ɵɵnextContext().ngIf;
+    const ctx_r19 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("measureType", ctx_r19.measureType.Area)("measureUnit", ctx_r19.measureAreaUnit.SquareMeters)("measure", measure_r17.area)("auto", ctx_r19.measureUnitsAuto)("placeholder", i0.ɵɵpipeBind1(1, 5, "igo.geo.measure.area"));
+} }
+function MeasurerComponent_ng_container_29_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, MeasurerComponent_ng_container_29_igo_measurer_item_1_Template, 2, 7, "igo-measurer-item", 13);
+    i0.ɵɵtemplate(2, MeasurerComponent_ng_container_29_igo_measurer_item_2_Template, 2, 7, "igo-measurer-item", 13);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r6 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r6.activeMeasureType === ctx_r6.measureType.Length || ctx_r6.activeMeasureType === ctx_r6.measureType.Area);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r6.activeMeasureType === ctx_r6.measureType.Area);
+} }
+function MeasurerComponent_mat_divider_31_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_button_35_Template(rf, ctx) { if (rf & 1) {
+    const _r27 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 15);
+    i0.ɵɵlistener("click", function MeasurerComponent_button_35_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r27); const ctx_r26 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r26.onCalculateClick()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelement(3, "mat-icon", 16);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r8 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.geo.measure.actionbar.calculate.tooltip"))("disabled", i0.ɵɵpipeBind1(2, 4, ctx_r8.selectedFeatures$).length === 0);
+} }
+function MeasurerComponent_button_38_Template(rf, ctx) { if (rf & 1) {
+    const _r29 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 17);
+    i0.ɵɵlistener("click", function MeasurerComponent_button_38_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r29); const ctx_r28 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r28.onDeleteClick()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelement(3, "mat-icon", 18);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r9 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.geo.measure.actionbar.delete.tooltip"))("disabled", i0.ɵɵpipeBind1(2, 4, ctx_r9.selectedFeatures$).length === 0);
+} }
+/**
+ * Tool to measure lengths and areas
+ */
+export class MeasurerComponent {
+    constructor(languageService, dialog, storageService) {
+        this.languageService = languageService;
+        this.dialog = dialog;
+        this.storageService = storageService;
+        /**
+         * Table template
+         * @internal
+         */
+        this.tableTemplate = {
+            selection: true,
+            selectMany: true,
+            selectionCheckbox: true,
+            sort: true,
+            columns: [
+                {
+                    name: 'length',
+                    title: this.languageService.translate.instant('igo.geo.measure.lengthHeader'),
+                    valueAccessor: (localFeature) => {
+                        const unit = this.activeLengthUnit;
+                        const measure = metersToUnit(localFeature.properties.measure.length, unit);
+                        return formatMeasure(measure, {
+                            decimal: 1,
+                            unit,
+                            unitAbbr: false,
+                            locale: 'fr'
+                        });
+                    }
+                },
+                {
+                    name: 'area',
+                    title: this.languageService.translate.instant('igo.geo.measure.areaHeader'),
+                    valueAccessor: (localFeature) => {
+                        const unit = this.activeAreaUnit;
+                        const measure = squareMetersToUnit(localFeature.properties.measure.area, unit);
+                        return measure ? formatMeasure(measure, {
+                            decimal: 1,
+                            unit,
+                            unitAbbr: false,
+                            locale: 'fr'
+                        }) : '';
+                    }
+                }
+            ]
+        };
+        this.subscriptions$$ = [];
+        /**
+         * Reference to the MeasureType enum
+         * @internal
+         */
+        this.measureType = MeasureType;
+        /**
+         * Reference to the AreaMeasureUnit enum
+         * @internal
+         */
+        this.measureAreaUnit = MeasureAreaUnit;
+        /**
+         * Reference to the LengthMeasureUnit enum
+         * @internal
+         */
+        this.measureLengthUnit = MeasureLengthUnit;
+        /**
+         * Whether measure units should be automatically determined
+         * @internal
+         */
+        this.measureUnitsAuto = false;
+        /**
+         * Whether display of distances of areas
+         * @internal
+         */
+        this.displayDistance = true;
+        /**
+         * Whether display of distances of lines
+         * @internal
+         */
+        this.displayLines = true;
+        /**
+         * Whether display of areas
+         * @internal
+         */
+        this.displayAreas = true;
+        /**
+         * Observable of line boolean
+         * @internal
+         */
+        this.hasLine$ = new BehaviorSubject(false);
+        /**
+         * Observable of area boolean
+         * @internal
+         */
+        this.hasArea$ = new BehaviorSubject(false);
+        /**
+         * Observable of area
+         * @internal
+         */
+        this.measure$ = new BehaviorSubject({});
+        /**
+         * Observable of selected features
+         * @internal
+         */
+        this.selectedFeatures$ = new BehaviorSubject([]);
+        /**
+         * OL draw source
+         * @internal
+         */
+        this.showTooltips = true;
+        /**
+         * Whether draw control toggle is disabled or not
+         * @internal
+         */
+        this.drawControlIsDisabled = true;
+        /**
+         * Active mlength unit
+         */
+        this.activeLengthUnit = MeasureLengthUnit.Meters;
+        /**
+         * Active area unit
+         */
+        this.activeAreaUnit = MeasureAreaUnit.SquareMeters;
+        /**
+         * OL draw source
+         */
+        this.olDrawSource = new OlVectorSource();
+        /**
+         * The minimum length a segment must have to display a tooltip.
+         * It also applies to area tooltips.
+         */
+        this.minSegmentLength = 10;
+    }
+    /**
+     * Measure type
+     * @internal
+     */
+    set activeMeasureType(value) { this.setActiveMeasureType(value); }
+    get activeMeasureType() { return this._activeMeasureType; }
+    /**
+     * Wheter one of the draw control is active
+     * @internal
+     */
+    get drawControlIsActive() {
+        return this.activeDrawControl !== undefined;
+    }
+    get projection() {
+        return this.map.ol.getView().getProjection().getCode();
+    }
+    /**
+     * Add draw controls and activate one
+     * @internal
+     */
+    ngOnInit() {
+        this.initStore();
+        this.createDrawLineControl();
+        this.createDrawPolygonControl();
+        this.createModifyControl();
+        this.toggleDrawControl();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        this.checkDistanceAreaToggle();
+        this.setActiveMeasureType(MeasureType.Length);
+    }
+    /**
+     * Clear the overlay layer and any interaction added by this component.
+     * @internal
+     */
+    ngOnDestroy() {
+        this.setActiveMeasureType(undefined);
+        this.deactivateModifyControl();
+        this.freezeStore();
+        this.subscriptions$$.map(s => s.unsubscribe());
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onMeasureTypeChange(measureType) {
+        this.activeMeasureType = measureType;
+    }
+    /**
+     * Activate or deactivate the current draw control
+     * @internal
+     */
+    onToggleDrawControl(toggle) {
+        if (toggle === true) {
+            this.toggleDrawControl();
+        }
+        else {
+            this.deactivateDrawControl();
+        }
+    }
+    /**
+     * Activate or deactivate the current draw control
+     * @internal
+     */
+    onToggleMeasureUnitsAuto(toggle) {
+        this.measureUnitsAuto = toggle;
+    }
+    /**
+     * Activate or deactivate the current display of distances of the areas
+     * @internal
+     */
+    onToggleDisplayDistance(toggle) {
+        this.displayDistance = toggle;
+        this.onDisplayDistance();
+        toggle ? (this.storageService.set('distanceToggle', true, StorageScope.SESSION)) :
+            (this.storageService.set('distanceToggle', false, StorageScope.SESSION));
+    }
+    /**
+     * Activate or deactivate the current display of distances of the lines
+     * @internal
+     */
+    onToggleDisplayLines(toggle) {
+        this.displayLines = toggle;
+        this.onDisplayLines();
+        toggle ? (this.storageService.set('linesToggle', true, StorageScope.SESSION)) :
+            (this.storageService.set('linesToggle', false, StorageScope.SESSION));
+    }
+    /**
+     * Activate or deactivate the current display of areas
+     * @internal
+     */
+    onToggleDisplayAreas(toggle) {
+        this.displayAreas = toggle;
+        this.onDisplayAreas();
+        toggle ? (this.storageService.set('areasToggle', true, StorageScope.SESSION)) :
+            (this.storageService.set('areasToggle', false, StorageScope.SESSION));
+    }
+    /**
+     * Set display parametres in current values
+     * @internal
+     */
+    checkDistanceAreaToggle() {
+        if (this.storageService.get('distanceToggle') === false) {
+            this.displayDistance = false;
+        }
+        if (this.storageService.get('linesToggle') === false) {
+            this.displayLines = false;
+        }
+        if (this.storageService.get('areasToggle') === false) {
+            this.displayAreas = false;
+        }
+    }
+    /**
+     * Activate or deactivate the current display of distances of areas
+     * @internal
+     */
+    onDisplayDistance() {
+        if (this.displayDistance) {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-polygone-segments')).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-polygone-segments')).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Activate or deactivate the current display of distances of lines
+     * @internal
+     */
+    onDisplayLines() {
+        if (this.displayLines) {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-line-segments')).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-line-segments')).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Activate or deactivate the current display of areas
+     * @internal
+     */
+    onDisplayAreas() {
+        if (this.displayAreas) {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-area')).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-area')).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onLengthUnitChange(unit) {
+        this.activeLengthUnit = unit;
+        this.table.refresh();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        if (this.activeOlGeometry !== undefined) {
+            this.updateTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onAreaUnitChange(unit) {
+        this.activeAreaUnit = unit;
+        this.table.refresh();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        if (this.activeOlGeometry !== undefined) {
+            this.updateTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+    }
+    onCalculateClick() {
+        const features = this.selectedFeatures$.value;
+        const area = features.reduce((sum, localFeature) => {
+            return sum + localFeature.properties.measure.area || 0;
+        }, 0);
+        const length = features.reduce((sum, localFeature) => {
+            if (localFeature.geometry.type === 'Polygon') {
+                return sum;
+            }
+            return sum + localFeature.properties.measure.length || 0;
+        }, 0);
+        const perimeter = features.reduce((sum, localFeature) => {
+            if (localFeature.geometry.type === 'LineString') {
+                return sum;
+            }
+            return sum + localFeature.properties.measure.length || 0;
+        }, 0);
+        this.openDialog({
+            area,
+            length,
+            perimeter
+        });
+    }
+    onDeleteClick() {
+        this.store.deleteMany(this.selectedFeatures$.value);
+        this.selectedFeatures$.value.forEach(selectedFeature => {
+            this.olDrawSource.getFeatures().forEach(drawingLayerFeature => {
+                const geometry = drawingLayerFeature.getGeometry();
+                if (selectedFeature.properties.id === geometry.ol_uid) {
+                    this.olDrawSource.removeFeature(drawingLayerFeature);
+                }
+            });
+        });
+    }
+    onModifyClick() {
+        if (this.selectedFeatures$.value.length !== 1) {
+            return;
+        }
+        if (this.modifyControl.active === true) {
+            this.deactivateModifyControl();
+            this.toggleDrawControl();
+        }
+        else {
+            const localFeature = this.selectedFeatures$.value[0];
+            const olFeatures = this.store.layer.ol.getSource().getFeatures();
+            const olFeature = olFeatures.find((_olFeature) => {
+                return _olFeature.get('id') === localFeature.properties.id;
+            });
+            if (olFeature !== undefined) {
+                this.deactivateDrawControl();
+                this.activateModifyControl();
+                const olGeometry = olFeature.getGeometry();
+                this.clearTooltipsOfOlGeometry(olGeometry);
+                this.modifyControl.setOlGeometry(olGeometry);
+            }
+        }
+    }
+    openDialog(data) {
+        this.dialog.open(MeasurerDialogComponent, { data });
+    }
+    /**
+     * Initialize the measure store and set up some listeners
+     * @internal
+     */
+    initStore() {
+        const store = this.store;
+        const layer = new VectorLayer({
+            title: this.languageService.translate.instant('igo.geo.measure.layerTitle'),
+            isIgoInternalLayer: true,
+            id: `igo-measures-${uuid()}`,
+            zIndex: 200,
+            source: new FeatureDataSource(),
+            style: createMeasureLayerStyle(),
+            showInLayerList: true,
+            exportable: true,
+            browsable: false,
+            workspace: { enabled: false }
+        });
+        tryBindStoreLayer(store, layer);
+        store.layer.visible = true;
+        layer.visible$.subscribe(visible => {
+            if (visible) {
+                Array.from(document.getElementsByClassName('igo-map-tooltip-measure')).map((value) => value.classList.remove('igo-map-tooltip-measure-by-display'));
+            }
+            else {
+                Array.from(document.getElementsByClassName('igo-map-tooltip-measure')).map((value) => value.classList.add('igo-map-tooltip-measure-by-display'));
+            }
+        });
+        tryAddLoadingStrategy(store);
+        tryAddSelectionStrategy(store, new FeatureStoreSelectionStrategy({
+            map: this.map,
+            many: true
+        }));
+        this.onFeatureAddedKey = store.source.ol.on('addfeature', (event) => {
+            const localFeature = event.feature;
+            const olGeometry = localFeature.getGeometry();
+            this.updateMeasureOfOlGeometry(olGeometry, localFeature.get('measure'));
+            this.onDisplayDistance();
+        });
+        this.onFeatureRemovedKey = store.source.ol.on('removefeature', (event) => {
+            const olGeometry = event.feature.getGeometry();
+            this.clearTooltipsOfOlGeometry(olGeometry);
+        });
+        this.selectedFeatures$$ = store.stateView.manyBy$((record) => {
+            return record.state.selected === true;
+        }).pipe(skip(1) // Skip initial emission
+        )
+            .subscribe((records) => {
+            if (this.modifyControl.active === true) {
+                this.deactivateModifyControl();
+            }
+            this.selectedFeatures$.next(records.map(record => record.entity));
+        });
+        this.subscriptions$$.push(this.store.entities$.subscribe(objectsExists => {
+            if (objectsExists.find(objectExist => objectExist.geometry.type === 'Polygon')) {
+                this.hasArea$.next(true);
+            }
+            else {
+                this.hasArea$.next(false);
+            }
+            if (objectsExists.find(objectExist => objectExist.geometry.type === 'LineString')) {
+                this.hasLine$.next(true);
+            }
+            else {
+                this.hasLine$.next(false);
+            }
+        }));
+        this.subscriptions$$.push(this.store.count$.subscribe(cnt => {
+            cnt >= 1 ?
+                this.store.layer.options.showInLayerList = true :
+                this.store.layer.options.showInLayerList = false;
+        }));
+    }
+    /**
+     * Freeze any store, meaning the layer is removed, strategies are deactivated
+     * and some listener removed
+     * @internal
+     */
+    freezeStore() {
+        const store = this.store;
+        this.selectedFeatures$$.unsubscribe();
+        unByKey(this.onFeatureAddedKey);
+        unByKey(this.onFeatureRemovedKey);
+        store.deactivateStrategyOfType(FeatureStoreLoadingStrategy);
+        store.deactivateStrategyOfType(FeatureStoreSelectionStrategy);
+    }
+    /**
+     * Create a draw line control
+     */
+    createDrawLineControl() {
+        this.drawLineControl = new DrawControl({
+            geometryType: 'LineString',
+            drawingLayerSource: this.olDrawSource,
+            interactionStyle: createMeasureInteractionStyle(),
+            drawingLayerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Create a draw polygon control
+     */
+    createDrawPolygonControl() {
+        this.drawPolygonControl = new DrawControl({
+            geometryType: 'Polygon',
+            drawingLayerSource: this.olDrawSource,
+            interactionStyle: createMeasureInteractionStyle(),
+            drawingLayerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Create a draw polygon control
+     */
+    createModifyControl() {
+        this.modifyControl = new ModifyControl({
+            source: this.olDrawSource,
+            drawStyle: createMeasureInteractionStyle(),
+            layerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Activate the right control
+     */
+    toggleDrawControl() {
+        this.deactivateDrawControl();
+        // this.deactivateModifyControl();
+        if (this.activeMeasureType === MeasureType.Length) {
+            this.activateDrawControl(this.drawLineControl);
+        }
+        else if (this.activeMeasureType === MeasureType.Area) {
+            this.activateDrawControl(this.drawPolygonControl);
+        }
+    }
+    /**
+     * Activate a given control
+     * @param drawControl Draw control
+     */
+    activateDrawControl(drawControl) {
+        this.drawControlIsDisabled = false;
+        this.activeDrawControl = drawControl;
+        this.drawStart$$ = drawControl.start$
+            .subscribe((olGeometry) => this.onDrawStart(olGeometry));
+        this.drawEnd$$ = drawControl.end$
+            .subscribe((olGeometry) => this.onDrawEnd(olGeometry));
+        this.drawChanges$$ = drawControl.changes$
+            .subscribe((olGeometry) => this.onDrawChanges(olGeometry));
+        this.drawChanges$$ = drawControl.abort$
+            .subscribe((olGeometry) => {
+            this.clearTooltipsOfOlGeometry(olGeometry);
+            this.clearMeasures();
+        });
+        drawControl.setOlMap(this.map.ol, false);
+    }
+    /**
+     * Deactivate the active draw control
+     */
+    deactivateDrawControl() {
+        if (this.activeDrawControl === undefined) {
+            return;
+        }
+        this.olDrawSource.clear();
+        if (this.drawStart$$ !== undefined) {
+            this.drawStart$$.unsubscribe();
+        }
+        if (this.drawEnd$$ !== undefined) {
+            this.drawEnd$$.unsubscribe();
+        }
+        if (this.drawChanges$$ !== undefined) {
+            this.drawChanges$$.unsubscribe();
+        }
+        this.clearTooltipsOfOlSource(this.olDrawSource);
+        if (this.activeOlGeometry !== undefined) {
+            this.clearTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+        this.activeDrawControl.setOlMap(undefined);
+        this.activeDrawControl = undefined;
+        this.activeOlGeometry = undefined;
+    }
+    setActiveMeasureType(measureType) {
+        this._activeMeasureType = measureType;
+        this.clearMeasures();
+        this.toggleDrawControl();
+    }
+    /**
+     * Clear the draw source and track the geometry being drawn
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawStart(olGeometry) {
+        this.activeOlGeometry = olGeometry;
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawEnd(olGeometry) {
+        this.activeOlGeometry = undefined;
+        this.finalizeMeasureOfOlGeometry(olGeometry);
+        this.addFeatureToStore(olGeometry);
+        this.clearTooltipsOfOlGeometry(olGeometry);
+        this.olDrawSource.clear(true);
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawChanges(olGeometry) {
+        const measure = measureOlGeometry(olGeometry, this.projection);
+        this.updateMeasureOfOlGeometry(olGeometry, Object.assign({}, measure, {
+            area: undefined // We don't want to display an area tooltip while drawing.
+        }));
+        this.measure$.next(measure);
+    }
+    /**
+     * Activate a given control
+     * @param modifyControl Modify control
+     */
+    activateModifyControl() {
+        const selection = this.store.getStrategyOfType(FeatureStoreSelectionStrategy);
+        selection.deactivate();
+        selection.clear();
+        this.modifyStart$$ = this.modifyControl.start$
+            .subscribe((olGeometry) => this.onModifyStart(olGeometry));
+        this.modifyEnd$$ = this.modifyControl.end$
+            .subscribe((olGeometry) => this.onModifyEnd(olGeometry));
+        this.modifyChanges$$ = this.modifyControl.changes$
+            .subscribe((olGeometry) => this.onModifyChanges(olGeometry));
+        this.modifyControl.setOlMap(this.map.ol);
+    }
+    /**
+     * Deactivate the active modify control
+     */
+    deactivateModifyControl() {
+        if (this.modifyStart$$ !== undefined) {
+            this.modifyStart$$.unsubscribe();
+        }
+        if (this.modifyEnd$$ !== undefined) {
+            this.modifyEnd$$.unsubscribe();
+        }
+        if (this.modifyChanges$$ !== undefined) {
+            this.modifyChanges$$.unsubscribe();
+        }
+        if (this.activeOlGeometry !== undefined) {
+            if (this.selectedFeatures$.value.length === 1) {
+                const localFeature = this.selectedFeatures$.value[0];
+                this.addFeatureToStore(this.activeOlGeometry, localFeature);
+            }
+            this.finalizeMeasureOfOlGeometry(this.activeOlGeometry);
+        }
+        this.olDrawSource.clear();
+        this.store.activateStrategyOfType(FeatureStoreSelectionStrategy);
+        this.activeOlGeometry = undefined;
+        this.modifyControl.setOlMap(undefined);
+    }
+    /**
+     * Clear the draw source and track the geometry being drawn
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyStart(olGeometry) {
+        this.onDrawStart(olGeometry);
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyChanges(olGeometry) {
+        this.onDrawChanges(olGeometry);
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyEnd(olGeometry) {
+        this.finalizeMeasureOfOlGeometry(olGeometry);
+    }
+    finalizeMeasureOfOlGeometry(olGeometry) {
+        const measure = measureOlGeometry(olGeometry, this.projection);
+        this.updateMeasureOfOlGeometry(olGeometry, measure);
+    }
+    /**
+     * Update measures observables
+     * @param olGeometry Ol linestring or polygon
+     * @param measure Measure
+     */
+    updateMeasureOfOlGeometry(olGeometry, measure) {
+        olGeometry.setProperties({ _measure: measure }, true);
+        this.updateTooltipsOfOlGeometry(olGeometry);
+    }
+    /**
+     * Clear the measures observables
+     */
+    clearMeasures() {
+        this.measure$.next({});
+    }
+    /**
+     * Add a feature with measures to the store. The loading stragegy of the store
+     * will trigger and add the feature to the map.
+     * @internal
+     */
+    addFeatureToStore(olGeometry, localFeature) {
+        const featureId = localFeature ? localFeature.properties.id : olGeometry.ol_uid;
+        const projection = this.map.ol.getView().getProjection();
+        const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {
+            featureProjection: projection,
+            dataProjection: projection
+        });
+        this.store.update({
+            type: FEATURE,
+            geometry,
+            projection: projection.getCode(),
+            properties: {
+                id: featureId,
+                measure: olGeometry.get('_measure')
+            },
+            meta: {
+                id: featureId
+            }
+        });
+    }
+    /**
+     * Update all the tooltips of an OL geometry
+     * @param olGeometry OL Geometry
+     * @param lengths Lengths of the OL geometry's segments
+     * @param measureUnit Display tooltip measure in those units
+     */
+    updateTooltipsOfOlGeometry(olGeometry) {
+        const measure = olGeometry.get('_measure');
+        const lengths = measure.lengths;
+        const area = measure.area;
+        const olMidpointsTooltips = updateOlTooltipsAtMidpoints(olGeometry);
+        if (lengths.length === olMidpointsTooltips.length) {
+            for (let i = 0; i < olMidpointsTooltips.length; i++) {
+                const length = lengths[i];
+                if (length !== undefined) {
+                    this.updateOlTooltip(olMidpointsTooltips[i], metersToUnit(length, this.activeLengthUnit), this.activeLengthUnit, MeasureType.Length);
+                }
+            }
+        }
+        if (area !== undefined) {
+            this.updateOlTooltip(updateOlTooltipAtCenter(olGeometry), squareMetersToUnit(area, this.activeAreaUnit), this.activeAreaUnit, MeasureType.Area);
+        }
+    }
+    /**
+     * Show the map tooltips of a geoemtry
+     */
+    showTooltipsOfOlGeometry(olGeometry) {
+        getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip) => {
+            if (this.shouldShowTooltip(olTooltip)) {
+                this.map.ol.addOverlay(olTooltip);
+            }
+        });
+    }
+    /**
+     * Clear the tooltips of an OL geometrys
+     * @param olGeometry OL geometry with tooltips
+     */
+    clearTooltipsOfOlGeometry(olGeometry) {
+        getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip) => {
+            if (olTooltip !== undefined && olTooltip.getMap() !== undefined) {
+                this.map.ol.removeOverlay(olTooltip);
+            }
+        });
+    }
+    /**
+     * Show the map tooltips of all the geometries of a source
+     */
+    updateTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            this.updateTooltipsOfOlGeometry(olFeature.getGeometry());
+        });
+    }
+    /**
+     * Show the map tooltips of all the geometries of a source
+     */
+    showTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            this.showTooltipsOfOlGeometry(olFeature.getGeometry());
+        });
+    }
+    /**
+     * Clear the map tooltips
+     * @param olDrawSource OL vector source
+     */
+    clearTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            const olGeometry = olFeature.getGeometry();
+            if (olGeometry !== undefined) {
+                this.clearTooltipsOfOlGeometry(olFeature.getGeometry());
+            }
+        });
+    }
+    /**
+     * Update an OL tooltip properties and inner HTML and add it to the map if possible
+     * @param olTooltip OL tooltip
+     * @param measure The measure valeu ti display
+     * @param measureUnit Display tooltip measure in those units
+     */
+    updateOlTooltip(olTooltip, measure, unit, type) {
+        olTooltip.setProperties({ _measure: measure, _unit: unit, _type: type }, true);
+        olTooltip.getElement().innerHTML = this.computeTooltipInnerHTML(olTooltip);
+        if (this.shouldShowTooltip(olTooltip)) {
+            this.map.ol.addOverlay(olTooltip);
+        }
+    }
+    /**
+     * Compute a tooltip's content
+     * @param olTooltip OL overlay
+     * @returns Inner HTML
+     */
+    computeTooltipInnerHTML(olTooltip) {
+        const properties = olTooltip.getProperties();
+        return formatMeasure(properties._measure, {
+            decimal: 1,
+            unit: properties._unit,
+            unitAbbr: true,
+            locale: 'fr'
+        }, this.languageService);
+    }
+    /**
+     * Whether a tooltip should be showned based on the length
+     * of the segment it is bound to.
+     * @param olTooltip OL overlay
+     * @returns True if the tooltip should be shown
+     */
+    shouldShowTooltip(olTooltip) {
+        if (this.showTooltips === false) {
+            return false;
+        }
+        const properties = olTooltip.getProperties();
+        const measure = properties._measure;
+        if (measure === undefined) {
+            return false;
+        }
+        if (properties._unit === MeasureType.Length) {
+            const minSegmentLength = metersToUnit(this.minSegmentLength, properties._unit) || 0;
+            return measure > Math.max(minSegmentLength, 0);
+        }
+        return true;
+    }
+}
+MeasurerComponent.ɵfac = function MeasurerComponent_Factory(t) { return new (t || MeasurerComponent)(i0.ɵɵdirectiveInject(i1.LanguageService), i0.ɵɵdirectiveInject(i2.MatDialog), i0.ɵɵdirectiveInject(i1.StorageService)); };
+MeasurerComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MeasurerComponent, selectors: [["igo-measurer"]], viewQuery: function MeasurerComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.table = _t.first);
+    } }, inputs: { map: "map", store: "store", activeMeasureType: "activeMeasureType", minSegmentLength: "minSegmentLength" }, decls: 43, vars: 60, consts: [[1, "measure-type-toggle", "mat-typography"], [3, "value", "change"], [3, "value"], [1, "measure-options", "mat-typography"], [3, "disabled", "checked", "labelPosition", "change"], [4, "ngIf"], [3, "checked", "labelPosition", "change", 4, "ngIf"], [3, "checked", "labelPosition", "change"], [1, "measure-store-buttons"], ["mat-icon-button", "", "color", "accent", 3, "matTooltip", "disabled", "click", 4, "ngIf"], ["mat-icon-button", "", "color", "warn", 3, "matTooltip", "disabled", "click", 4, "ngIf"], [1, "table-compact", 3, "store", "template"], ["table", ""], [3, "measureType", "measureUnit", "measure", "auto", "placeholder", "measureUnitChange", 4, "ngIf"], [3, "measureType", "measureUnit", "measure", "auto", "placeholder", "measureUnitChange"], ["mat-icon-button", "", "color", "accent", 3, "matTooltip", "disabled", "click"], ["svgIcon", "calculator"], ["mat-icon-button", "", "color", "warn", 3, "matTooltip", "disabled", "click"], ["svgIcon", "delete"]], template: function MeasurerComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div")(1, "div", 0)(2, "mat-button-toggle-group", 1);
+        i0.ɵɵlistener("change", function MeasurerComponent_Template_mat_button_toggle_group_change_2_listener($event) { return ctx.onMeasureTypeChange($event.value); });
+        i0.ɵɵelementStart(3, "mat-button-toggle", 2);
+        i0.ɵɵtext(4);
+        i0.ɵɵpipe(5, "translate");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(6, "mat-button-toggle", 2);
+        i0.ɵɵtext(7);
+        i0.ɵɵpipe(8, "translate");
+        i0.ɵɵelementEnd()()();
+        i0.ɵɵelementStart(9, "div", 3)(10, "mat-slide-toggle", 4);
+        i0.ɵɵlistener("change", function MeasurerComponent_Template_mat_slide_toggle_change_10_listener($event) { return ctx.onToggleDrawControl($event.checked); });
+        i0.ɵɵtext(11);
+        i0.ɵɵpipe(12, "translate");
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(13, MeasurerComponent_mat_divider_13_Template, 1, 0, "mat-divider", 5);
+        i0.ɵɵpipe(14, "async");
+        i0.ɵɵtemplate(15, MeasurerComponent_mat_slide_toggle_15_Template, 3, 5, "mat-slide-toggle", 6);
+        i0.ɵɵpipe(16, "async");
+        i0.ɵɵtemplate(17, MeasurerComponent_mat_divider_17_Template, 1, 0, "mat-divider", 5);
+        i0.ɵɵpipe(18, "async");
+        i0.ɵɵpipe(19, "async");
+        i0.ɵɵtemplate(20, MeasurerComponent_mat_slide_toggle_20_Template, 3, 5, "mat-slide-toggle", 6);
+        i0.ɵɵpipe(21, "async");
+        i0.ɵɵtemplate(22, MeasurerComponent_mat_slide_toggle_22_Template, 3, 5, "mat-slide-toggle", 6);
+        i0.ɵɵpipe(23, "async");
+        i0.ɵɵtemplate(24, MeasurerComponent_mat_divider_24_Template, 1, 0, "mat-divider", 5);
+        i0.ɵɵpipe(25, "async");
+        i0.ɵɵelementStart(26, "mat-slide-toggle", 7);
+        i0.ɵɵlistener("change", function MeasurerComponent_Template_mat_slide_toggle_change_26_listener($event) { return ctx.onToggleMeasureUnitsAuto($event.checked); });
+        i0.ɵɵtext(27);
+        i0.ɵɵpipe(28, "translate");
+        i0.ɵɵelementEnd()();
+        i0.ɵɵtemplate(29, MeasurerComponent_ng_container_29_Template, 3, 2, "ng-container", 5);
+        i0.ɵɵpipe(30, "async");
+        i0.ɵɵtemplate(31, MeasurerComponent_mat_divider_31_Template, 1, 0, "mat-divider", 5);
+        i0.ɵɵpipe(32, "async");
+        i0.ɵɵpipe(33, "async");
+        i0.ɵɵelementStart(34, "div", 8);
+        i0.ɵɵtemplate(35, MeasurerComponent_button_35_Template, 4, 6, "button", 9);
+        i0.ɵɵpipe(36, "async");
+        i0.ɵɵpipe(37, "async");
+        i0.ɵɵtemplate(38, MeasurerComponent_button_38_Template, 4, 6, "button", 10);
+        i0.ɵɵpipe(39, "async");
+        i0.ɵɵpipe(40, "async");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelement(41, "igo-entity-table", 11, 12);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("value", ctx.activeMeasureType);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("value", ctx.measureType.Length);
+        i0.ɵɵadvance(1);
+        i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 24, "igo.geo.measure." + ctx.measureType.Length), " ");
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("value", ctx.measureType.Area);
+        i0.ɵɵadvance(1);
+        i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(8, 26, "igo.geo.measure." + ctx.measureType.Area), " ");
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("disabled", ctx.drawControlIsDisabled)("checked", ctx.drawControlIsActive)("labelPosition", "before");
+        i0.ɵɵadvance(1);
+        i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(12, 28, "igo.geo.measure.toggleActive"), " ");
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(14, 30, ctx.hasLine$));
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(16, 32, ctx.hasLine$));
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(18, 34, ctx.hasLine$) || i0.ɵɵpipeBind1(19, 36, ctx.hasArea$));
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(21, 38, ctx.hasArea$));
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(23, 40, ctx.hasArea$));
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(25, 42, ctx.hasArea$));
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("checked", ctx.measureUnitsAuto)("labelPosition", "before");
+        i0.ɵɵadvance(1);
+        i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(28, 44, "igo.geo.measure.toggleAutoUnits"), " ");
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(30, 46, ctx.measure$));
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(32, 48, ctx.hasLine$) || i0.ɵɵpipeBind1(33, 50, ctx.hasArea$));
+        i0.ɵɵadvance(4);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(36, 52, ctx.hasLine$) || i0.ɵɵpipeBind1(37, 54, ctx.hasArea$));
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(39, 56, ctx.hasLine$) || i0.ɵɵpipeBind1(40, 58, ctx.hasArea$));
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("store", ctx.store)("template", ctx.tableTemplate);
+    } }, styles: [".measure-type-toggle[_ngcontent-%COMP%]{padding:10px;text-align:center}.measure-type-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]{width:100%}.measure-type-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]   mat-button-toggle[_ngcontent-%COMP%]{width:50%}.measure-options[_ngcontent-%COMP%]{overflow-x:hidden}.measure-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]{width:100%;margin:10px}.measure-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mat-slide-toggle-content{width:calc(100% - 60px)}.measure-store-buttons[_ngcontent-%COMP%]{margin-left:-2px}.measure-store-buttons[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:first-of-type{margin-left:14px}.table-compact[_ngcontent-%COMP%]     .mat-header-cell.mat-column-selectionCheckbox{width:52px}"], changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MeasurerComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-measurer', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div>\r\n  <div class=\"measure-type-toggle mat-typography\">\r\n    <mat-button-toggle-group\r\n      [value]=\"activeMeasureType\"\r\n      (change)=\"onMeasureTypeChange($event.value)\">\r\n      <mat-button-toggle [value]=\"measureType.Length\">\r\n        {{('igo.geo.measure.' + measureType.Length) | translate}}\r\n      </mat-button-toggle>\r\n      <mat-button-toggle [value]=\"measureType.Area\">\r\n        {{('igo.geo.measure.' + measureType.Area) | translate}}\r\n      </mat-button-toggle>\r\n    </mat-button-toggle-group>\r\n  </div>\r\n\r\n  <div class=\"measure-options mat-typography\">\r\n    <mat-slide-toggle\r\n      [disabled]=\"drawControlIsDisabled\"\r\n      [checked]=\"drawControlIsActive\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDrawControl($event.checked)\">\r\n      {{'igo.geo.measure.toggleActive' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-divider *ngIf=\"(hasLine$ | async)\"></mat-divider>\r\n\r\n    <mat-slide-toggle *ngIf=\"(hasLine$ | async)\"\r\n      [checked]=\"displayLines\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDisplayLines($event.checked)\">\r\n      {{'igo.geo.measure.toggleDisplayLines' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\r\n\r\n    <mat-slide-toggle *ngIf=\"(hasArea$ | async)\"\r\n      [checked]=\"displayDistance\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDisplayDistance($event.checked)\">\r\n      {{'igo.geo.measure.toggleDisplayDistance' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-slide-toggle *ngIf=\"(hasArea$ | async)\"\r\n      [checked]=\"displayAreas\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDisplayAreas($event.checked)\">\r\n      {{'igo.geo.measure.toggleDisplayAreas' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-divider *ngIf=\"(hasArea$ | async)\"></mat-divider>\r\n\r\n    <mat-slide-toggle\r\n      [checked]=\"measureUnitsAuto\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleMeasureUnitsAuto($event.checked)\">\r\n      {{'igo.geo.measure.toggleAutoUnits' | translate}}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <ng-container *ngIf=\"measure$ | async as measure\">\r\n    <igo-measurer-item *ngIf=\"activeMeasureType === measureType.Length || activeMeasureType === measureType.Area\"\r\n      [measureType]=\"measureType.Length\"\r\n      [measureUnit]=\"measureLengthUnit.Meters\"\r\n      [measure]=\"measure.length\"\r\n      [auto]=\"measureUnitsAuto\"\r\n      [placeholder]=\"(activeMeasureType === measureType.Area ? 'igo.geo.measure.perimeter' : 'igo.geo.measure.length') | translate\"\r\n      (measureUnitChange)=\"onLengthUnitChange($event)\">\r\n    </igo-measurer-item>\r\n\r\n    <igo-measurer-item *ngIf=\"activeMeasureType === measureType.Area\"\r\n      [measureType]=\"measureType.Area\"\r\n      [measureUnit]=\"measureAreaUnit.SquareMeters\"\r\n      [measure]=\"measure.area\"\r\n      [auto]=\"measureUnitsAuto\"\r\n      [placeholder]=\"'igo.geo.measure.area' | translate\"\r\n      (measureUnitChange)=\"onAreaUnitChange($event)\">\r\n    </igo-measurer-item>\r\n  </ng-container>\r\n\r\n  <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\r\n\r\n  <div class=\"measure-store-buttons\">\r\n    <button *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\r\n      mat-icon-button\r\n      [matTooltip]=\"'igo.geo.measure.actionbar.calculate.tooltip' | translate\"\r\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\r\n      color=\"accent\"\r\n      (click)=\"onCalculateClick()\">\r\n      <mat-icon svgIcon=\"calculator\"></mat-icon>\r\n    </button>\r\n\r\n    <button *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\r\n      mat-icon-button\r\n      [matTooltip]=\"'igo.geo.measure.actionbar.delete.tooltip' | translate\"\r\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\r\n      color=\"warn\"\r\n      (click)=\"onDeleteClick()\">\r\n      <mat-icon svgIcon=\"delete\"></mat-icon>\r\n    </button>\r\n\r\n    <!--button\r\n      mat-icon-button\r\n      [matTooltip]=\"'igo.geo.measure.actionbar.modify.tooltip' | translate\"\r\n      [disabled]=\"(selectedFeatures$ | async).length !== 1\"\r\n      (click)=\"onModifyClick()\">\r\n      <mat-icon svgIcon=\"edit\"></mat-icon>\r\n    </button-->\r\n  </div>\r\n\r\n  <igo-entity-table\r\n    #table\r\n    class=\"table-compact\"\r\n    [store]=\"store\"\r\n    [template]=\"tableTemplate\">\r\n  </igo-entity-table>\r\n</div>\r\n", styles: [".measure-type-toggle{padding:10px;text-align:center}.measure-type-toggle mat-button-toggle-group{width:100%}.measure-type-toggle mat-button-toggle-group mat-button-toggle{width:50%}.measure-options{overflow-x:hidden}.measure-options mat-slide-toggle{width:100%;margin:10px}.measure-options mat-slide-toggle ::ng-deep .mat-slide-toggle-content{width:calc(100% - 60px)}.measure-store-buttons{margin-left:-2px}.measure-store-buttons button:first-of-type{margin-left:14px}.table-compact ::ng-deep .mat-header-cell.mat-column-selectionCheckbox{width:52px}\n"] }]
+    }], function () { return [{ type: i1.LanguageService }, { type: i2.MatDialog }, { type: i1.StorageService }]; }, { map: [{
+            type: Input
+        }], store: [{
+            type: Input
+        }], activeMeasureType: [{
+            type: Input
+        }], minSegmentLength: [{
+            type: Input
+        }], table: [{
+            type: ViewChild,
+            args: ['table', { static: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"measurer.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/measure/measurer/measurer.component.ts","../../../../../../packages/geo/src/lib/measure/measurer/measurer.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  Input,\r\n  OnInit,\r\n  OnDestroy,\r\n  ChangeDetectionStrategy,\r\n  ViewChild\r\n} from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\n\r\nimport { BehaviorSubject, Subscription } from 'rxjs';\r\nimport { skip } from 'rxjs/operators';\r\n\r\nimport OlStyle from 'ol/style/Style';\r\nimport OlGeoJSON from 'ol/format/GeoJSON';\r\nimport OlVectorSource from 'ol/source/Vector';\r\nimport { VectorSourceEvent as OlVectorSourceEvent } from 'ol/source/Vector';\r\nimport OlLineString from 'ol/geom/LineString';\r\nimport OlPolygon from 'ol/geom/Polygon';\r\nimport OlFeature from 'ol/Feature';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport OlOverlay from 'ol/Overlay';\r\nimport { unByKey } from 'ol/Observable';\r\n\r\nimport { LanguageService, StorageScope, StorageService } from '@igo2/core';\r\nimport { EntityRecord, EntityTableTemplate } from '@igo2/common';\r\nimport type { EntityTableComponent } from '@igo2/common';\r\nimport { uuid } from '@igo2/utils';\r\n\r\nimport { FeatureDataSource } from '../../datasource';\r\nimport {\r\n  FEATURE,\r\n  FeatureStore,\r\n  FeatureStoreLoadingStrategy,\r\n  FeatureStoreSelectionStrategy,\r\n  tryBindStoreLayer,\r\n  tryAddLoadingStrategy,\r\n  tryAddSelectionStrategy\r\n} from '../../feature';\r\nimport { DrawControl, ModifyControl } from '../../geometry/shared';\r\nimport { VectorLayer } from '../../layer';\r\nimport { IgoMap } from '../../map';\r\n\r\nimport { Measure, MeasurerDialogData, FeatureWithMeasure } from '../shared/measure.interfaces';\r\nimport {\r\n  MeasureType,\r\n  MeasureAreaUnit,\r\n  MeasureLengthUnit,\r\n} from '../shared/measure.enum';\r\nimport {\r\n  measureOlGeometry,\r\n  createMeasureInteractionStyle,\r\n  createMeasureLayerStyle,\r\n  updateOlTooltipsAtMidpoints,\r\n  updateOlTooltipAtCenter,\r\n  getTooltipsOfOlGeometry,\r\n  squareMetersToUnit,\r\n  metersToUnit,\r\n  formatMeasure\r\n} from '../shared/measure.utils';\r\nimport { MeasurerDialogComponent } from './measurer-dialog.component';\r\n\r\n/**\r\n * Tool to measure lengths and areas\r\n */\r\n@Component({\r\n  selector: 'igo-measurer',\r\n  templateUrl: './measurer.component.html',\r\n  styleUrls: ['./measurer.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class MeasurerComponent implements OnInit, OnDestroy {\r\n\r\n  /**\r\n   * Table template\r\n   * @internal\r\n   */\r\n  public tableTemplate: EntityTableTemplate = {\r\n    selection: true,\r\n    selectMany: true,\r\n    selectionCheckbox: true,\r\n    sort: true,\r\n    columns: [\r\n      {\r\n        name: 'length',\r\n        title: this.languageService.translate.instant('igo.geo.measure.lengthHeader'),\r\n        valueAccessor: (localFeature: FeatureWithMeasure) => {\r\n          const unit = this.activeLengthUnit;\r\n          const measure = metersToUnit(localFeature.properties.measure.length, unit);\r\n          return formatMeasure(measure, {\r\n            decimal: 1,\r\n            unit,\r\n            unitAbbr: false,\r\n            locale: 'fr'\r\n          });\r\n        }\r\n      },\r\n      {\r\n        name: 'area',\r\n        title: this.languageService.translate.instant('igo.geo.measure.areaHeader'),\r\n        valueAccessor: (localFeature: FeatureWithMeasure) => {\r\n          const unit = this.activeAreaUnit;\r\n          const measure = squareMetersToUnit(localFeature.properties.measure.area, unit);\r\n          return measure ? formatMeasure(measure, {\r\n            decimal: 1,\r\n            unit,\r\n            unitAbbr: false,\r\n            locale: 'fr'\r\n          }) : '';\r\n        }\r\n      }\r\n    ]\r\n  };\r\n\r\n  private subscriptions$$: Subscription[] = [];\r\n\r\n  /**\r\n   * Reference to the MeasureType enum\r\n   * @internal\r\n   */\r\n  public measureType = MeasureType;\r\n\r\n  /**\r\n   * Reference to the AreaMeasureUnit enum\r\n   * @internal\r\n   */\r\n  public measureAreaUnit = MeasureAreaUnit;\r\n\r\n  /**\r\n   * Reference to the LengthMeasureUnit enum\r\n   * @internal\r\n   */\r\n  public measureLengthUnit = MeasureLengthUnit;\r\n\r\n  /**\r\n   * Whether measure units should be automatically determined\r\n   * @internal\r\n   */\r\n  public measureUnitsAuto: boolean = false;\r\n\r\n  /**\r\n   * Whether display of distances of areas\r\n   * @internal\r\n   */\r\n  public displayDistance: boolean = true;\r\n\r\n  /**\r\n   * Whether display of distances of lines\r\n   * @internal\r\n   */\r\n  public displayLines: boolean = true;\r\n\r\n  /**\r\n   * Whether display of areas\r\n   * @internal\r\n   */\r\n  public displayAreas: boolean = true;\r\n\r\n  /**\r\n   * Observable of line boolean\r\n   * @internal\r\n   */\r\n   public hasLine$: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n\r\n  /**\r\n   * Observable of area boolean\r\n   * @internal\r\n   */\r\n  public hasArea$: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n\r\n  /**\r\n   * Observable of area\r\n   * @internal\r\n   */\r\n  public measure$: BehaviorSubject<Measure> = new BehaviorSubject({});\r\n\r\n  /**\r\n   * Observable of selected features\r\n   * @internal\r\n   */\r\n  public selectedFeatures$: BehaviorSubject<FeatureWithMeasure[]> = new BehaviorSubject([]);\r\n\r\n  /**\r\n   * OL draw source\r\n   * @internal\r\n   */\r\n  public showTooltips: boolean = true;\r\n\r\n  /**\r\n   * Whether draw control toggle is disabled or not\r\n   * @internal\r\n   */\r\n  public drawControlIsDisabled: boolean = true;\r\n\r\n  /**\r\n   * Draw line control\r\n   */\r\n  private drawLineControl: DrawControl;\r\n\r\n  /**\r\n   * Draw polygon control\r\n   */\r\n  private drawPolygonControl: DrawControl;\r\n\r\n  /**\r\n   * Modify control\r\n   */\r\n  private modifyControl: ModifyControl;\r\n\r\n  /**\r\n   * Active OL geometry\r\n   */\r\n  private activeOlGeometry: OlLineString | OlPolygon;\r\n\r\n  /**\r\n   * Active mlength unit\r\n   */\r\n  private activeLengthUnit: MeasureLengthUnit = MeasureLengthUnit.Meters;\r\n\r\n  /**\r\n   * Active area unit\r\n   */\r\n  private activeAreaUnit: MeasureAreaUnit = MeasureAreaUnit.SquareMeters;\r\n\r\n  /**\r\n   * Feature added listener key\r\n   */\r\n  private onFeatureAddedKey;\r\n\r\n  /**\r\n   * Feature removed listener key\r\n   */\r\n  private onFeatureRemovedKey;\r\n\r\n  /**\r\n   * Active draw control\r\n   * @internal\r\n   */\r\n  private activeDrawControl: DrawControl;\r\n\r\n  /**\r\n   * Subscription to draw start\r\n   */\r\n  private drawStart$$: Subscription;\r\n\r\n  /**\r\n   * Subscription to draw end\r\n   */\r\n  private drawEnd$$: Subscription;\r\n\r\n  /**\r\n   * Subscription to controls changes\r\n   */\r\n  private drawChanges$$: Subscription;\r\n\r\n  /**\r\n   * Subscription to modify start\r\n   */\r\n  private modifyStart$$: Subscription;\r\n\r\n  /**\r\n   * Subscription to modify end\r\n   */\r\n  private modifyEnd$$: Subscription;\r\n\r\n  /**\r\n   * Subscription to controls changes\r\n   */\r\n  private modifyChanges$$: Subscription;\r\n\r\n  /**\r\n   * Subscription to measures selection\r\n   */\r\n  private selectedFeatures$$: Subscription;\r\n\r\n  /**\r\n   * OL draw source\r\n   */\r\n  private olDrawSource = new OlVectorSource();\r\n\r\n  /**\r\n   * The map to measure on\r\n   */\r\n  @Input() map: IgoMap;\r\n\r\n  /**\r\n   * The measures store\r\n   */\r\n  @Input() store: FeatureStore<FeatureWithMeasure>;\r\n\r\n  /**\r\n   * Measure type\r\n   * @internal\r\n   */\r\n  @Input()\r\n  set activeMeasureType(value: MeasureType) { this.setActiveMeasureType(value); }\r\n  get activeMeasureType(): MeasureType { return this._activeMeasureType; }\r\n  private _activeMeasureType: MeasureType;\r\n\r\n  /**\r\n   * The minimum length a segment must have to display a tooltip.\r\n   * It also applies to area tooltips.\r\n   */\r\n  @Input() minSegmentLength: number = 10;\r\n\r\n  @ViewChild('table', { static: true }) table: EntityTableComponent;\r\n\r\n  /**\r\n   * Wheter one of the draw control is active\r\n   * @internal\r\n   */\r\n  get drawControlIsActive(): boolean {\r\n    return this.activeDrawControl !== undefined;\r\n  }\r\n\r\n  get projection(): string {\r\n    return this.map.ol.getView().getProjection().getCode();\r\n  }\r\n\r\n  constructor(\r\n    private languageService: LanguageService,\r\n    private dialog: MatDialog,\r\n    private storageService: StorageService\r\n  ) {}\r\n\r\n  /**\r\n   * Add draw controls and activate one\r\n   * @internal\r\n   */\r\n  ngOnInit() {\r\n    this.initStore();\r\n    this.createDrawLineControl();\r\n    this.createDrawPolygonControl();\r\n    this.createModifyControl();\r\n    this.toggleDrawControl();\r\n    this.updateTooltipsOfOlSource(this.store.source.ol);\r\n    this.checkDistanceAreaToggle();\r\n    this.setActiveMeasureType(MeasureType.Length);\r\n  }\r\n\r\n  /**\r\n   * Clear the overlay layer and any interaction added by this component.\r\n   * @internal\r\n   */\r\n  ngOnDestroy() {\r\n    this.setActiveMeasureType(undefined);\r\n    this.deactivateModifyControl();\r\n    this.freezeStore();\r\n    this.subscriptions$$.map(s => s.unsubscribe());\r\n  }\r\n\r\n  /**\r\n   * Set the measure type\r\n   * @internal\r\n   */\r\n  onMeasureTypeChange(measureType: MeasureType) {\r\n    this.activeMeasureType = measureType;\r\n  }\r\n\r\n  /**\r\n   * Activate or deactivate the current draw control\r\n   * @internal\r\n   */\r\n  onToggleDrawControl(toggle: boolean) {\r\n    if (toggle === true) {\r\n      this.toggleDrawControl();\r\n    } else {\r\n      this.deactivateDrawControl();\r\n    }\r\n  }\r\n\r\n\r\n  /**\r\n   * Activate or deactivate the current draw control\r\n   * @internal\r\n   */\r\n   onToggleMeasureUnitsAuto(toggle: boolean) {\r\n    this.measureUnitsAuto = toggle;\r\n  }\r\n\r\n  /**\r\n   * Activate or deactivate the current display of distances of the areas\r\n   * @internal\r\n   */\r\n  onToggleDisplayDistance(toggle: boolean) {\r\n    this.displayDistance = toggle;\r\n    this.onDisplayDistance();\r\n    toggle ? (this.storageService.set('distanceToggle', true, StorageScope.SESSION)) :\r\n     (this.storageService.set('distanceToggle', false, StorageScope.SESSION));\r\n  }\r\n\r\n  /**\r\n   * Activate or deactivate the current display of distances of the lines\r\n   * @internal\r\n   */\r\n  onToggleDisplayLines(toggle: boolean) {\r\n    this.displayLines = toggle;\r\n    this.onDisplayLines();\r\n    toggle ? (this.storageService.set('linesToggle', true, StorageScope.SESSION)) :\r\n     (this.storageService.set('linesToggle', false, StorageScope.SESSION));\r\n  }\r\n\r\n  /**\r\n   * Activate or deactivate the current display of areas\r\n   * @internal\r\n   */\r\n  onToggleDisplayAreas(toggle: boolean) {\r\n    this.displayAreas = toggle;\r\n    this.onDisplayAreas();\r\n    toggle ? (this.storageService.set('areasToggle', true, StorageScope.SESSION)) :\r\n     (this.storageService.set('areasToggle', false, StorageScope.SESSION));\r\n  }\r\n\r\n  /**\r\n   * Set display parametres in current values\r\n   * @internal\r\n   */\r\n  checkDistanceAreaToggle(){\r\n    if (this.storageService.get('distanceToggle') === false){\r\n      this.displayDistance = false;\r\n    }\r\n    if (this.storageService.get('linesToggle') === false){\r\n      this.displayLines = false;\r\n    }\r\n    if (this.storageService.get('areasToggle') === false){\r\n      this.displayAreas = false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Activate or deactivate the current display of distances of areas\r\n   * @internal\r\n   */\r\n  onDisplayDistance() {\r\n    if (this.displayDistance) {\r\n      Array.from(document.getElementsByClassName('igo-map-tooltip-measure-polygone-segments')).map((value: Element) =>\r\n        value.classList.remove('igo-map-tooltip-hidden'));\r\n    } else {\r\n      Array.from(document.getElementsByClassName('igo-map-tooltip-measure-polygone-segments')).map((value: Element) =>\r\n        value.classList.add('igo-map-tooltip-hidden'));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Activate or deactivate the current display of distances of lines\r\n   * @internal\r\n   */\r\n  onDisplayLines() {\r\n    if (this.displayLines) {\r\n      Array.from(document.getElementsByClassName('igo-map-tooltip-measure-line-segments')).map((value: Element) =>\r\n        value.classList.remove('igo-map-tooltip-hidden'));\r\n    } else {\r\n      Array.from(document.getElementsByClassName('igo-map-tooltip-measure-line-segments')).map((value: Element) =>\r\n        value.classList.add('igo-map-tooltip-hidden'));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Activate or deactivate the current display of areas\r\n   * @internal\r\n   */\r\n  onDisplayAreas() {\r\n    if (this.displayAreas) {\r\n      Array.from(document.getElementsByClassName('igo-map-tooltip-measure-area')).map((value: Element) =>\r\n        value.classList.remove('igo-map-tooltip-hidden'));\r\n    } else {\r\n      Array.from(document.getElementsByClassName('igo-map-tooltip-measure-area')).map((value: Element) =>\r\n        value.classList.add('igo-map-tooltip-hidden'));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Set the measure type\r\n   * @internal\r\n   */\r\n  onLengthUnitChange(unit: MeasureLengthUnit) {\r\n    this.activeLengthUnit = unit;\r\n    this.table.refresh();\r\n    this.updateTooltipsOfOlSource(this.store.source.ol);\r\n    if (this.activeOlGeometry !== undefined) {\r\n      this.updateTooltipsOfOlGeometry(this.activeOlGeometry);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Set the measure type\r\n   * @internal\r\n   */\r\n  onAreaUnitChange(unit: MeasureAreaUnit) {\r\n    this.activeAreaUnit = unit;\r\n    this.table.refresh();\r\n    this.updateTooltipsOfOlSource(this.store.source.ol);\r\n    if (this.activeOlGeometry !== undefined) {\r\n      this.updateTooltipsOfOlGeometry(this.activeOlGeometry);\r\n    }\r\n  }\r\n\r\n  onCalculateClick() {\r\n    const features = this.selectedFeatures$.value;\r\n    const area = features.reduce((sum: number, localFeature: FeatureWithMeasure) => {\r\n      return sum + localFeature.properties.measure.area || 0;\r\n    }, 0);\r\n    const length = features.reduce((sum: number, localFeature: FeatureWithMeasure) => {\r\n      if (localFeature.geometry.type === 'Polygon') {\r\n        return sum;\r\n      }\r\n      return sum + localFeature.properties.measure.length || 0;\r\n    }, 0);\r\n    const perimeter = features.reduce((sum: number, localFeature: FeatureWithMeasure) => {\r\n      if (localFeature.geometry.type === 'LineString') {\r\n        return sum;\r\n      }\r\n      return sum + localFeature.properties.measure.length || 0;\r\n    }, 0);\r\n\r\n    this.openDialog({\r\n      area,\r\n      length,\r\n      perimeter\r\n    });\r\n  }\r\n\r\n  onDeleteClick() {\r\n    this.store.deleteMany(this.selectedFeatures$.value);\r\n    this.selectedFeatures$.value.forEach(selectedFeature => {\r\n      this.olDrawSource.getFeatures().forEach(drawingLayerFeature => {\r\n        const geometry = drawingLayerFeature.getGeometry() as any;\r\n        if (selectedFeature.properties.id === geometry.ol_uid) {\r\n          this.olDrawSource.removeFeature(drawingLayerFeature);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  onModifyClick() {\r\n    if (this.selectedFeatures$.value.length !== 1) { return; }\r\n\r\n    if (this.modifyControl.active === true) {\r\n      this.deactivateModifyControl();\r\n      this.toggleDrawControl();\r\n    } else {\r\n      const localFeature = this.selectedFeatures$.value[0];\r\n      const olFeatures = this.store.layer.ol.getSource().getFeatures();\r\n      const olFeature = olFeatures.find((_olFeature: OlFeature<OlGeometry>) => {\r\n        return _olFeature.get('id') === localFeature.properties.id;\r\n      });\r\n\r\n      if (olFeature !== undefined) {\r\n        this.deactivateDrawControl();\r\n        this.activateModifyControl();\r\n\r\n        const olGeometry = olFeature.getGeometry();\r\n        this.clearTooltipsOfOlGeometry(olGeometry as (OlLineString | OlPolygon));\r\n        this.modifyControl.setOlGeometry(olGeometry);\r\n      }\r\n    }\r\n  }\r\n\r\n  private openDialog(data: MeasurerDialogData): void {\r\n    this.dialog.open(MeasurerDialogComponent, {data});\r\n  }\r\n\r\n  /**\r\n   * Initialize the measure store and set up some listeners\r\n   * @internal\r\n   */\r\n  private initStore() {\r\n    const store = this.store;\r\n\r\n    const layer = new VectorLayer({\r\n      title: this.languageService.translate.instant('igo.geo.measure.layerTitle'),\r\n      isIgoInternalLayer: true,\r\n      id: `igo-measures-${uuid()}`,\r\n      zIndex: 200,\r\n      source: new FeatureDataSource(),\r\n      style: createMeasureLayerStyle(),\r\n      showInLayerList: true,\r\n      exportable: true,\r\n      browsable: false,\r\n      workspace: { enabled: false }\r\n    });\r\n    tryBindStoreLayer(store, layer);\r\n    store.layer.visible = true;\r\n    layer.visible$.subscribe(visible => {\r\n      if (visible) {\r\n        Array.from(document.getElementsByClassName('igo-map-tooltip-measure')).map((value: Element) =>\r\n        value.classList.remove('igo-map-tooltip-measure-by-display'));\r\n      }\r\n      else {\r\n        Array.from(document.getElementsByClassName('igo-map-tooltip-measure')).map((value: Element) =>\r\n        value.classList.add('igo-map-tooltip-measure-by-display'));\r\n      }\r\n    });\r\n\r\n    tryAddLoadingStrategy(store);\r\n\r\n    tryAddSelectionStrategy(store, new FeatureStoreSelectionStrategy({\r\n      map: this.map,\r\n      many: true\r\n    }));\r\n\r\n    this.onFeatureAddedKey = store.source.ol.on('addfeature', (event: OlVectorSourceEvent<OlGeometry>) => {\r\n      const localFeature = event.feature;\r\n      const olGeometry = localFeature.getGeometry() as any;\r\n      this.updateMeasureOfOlGeometry(olGeometry, localFeature.get('measure'));\r\n      this.onDisplayDistance();\r\n    });\r\n\r\n    this.onFeatureRemovedKey = store.source.ol.on('removefeature', (event: OlVectorSourceEvent<OlGeometry>) => {\r\n      const olGeometry = event.feature.getGeometry() as any;\r\n      this.clearTooltipsOfOlGeometry(olGeometry);\r\n    });\r\n\r\n    this.selectedFeatures$$ = store.stateView.manyBy$((record: EntityRecord<FeatureWithMeasure>) => {\r\n      return record.state.selected === true;\r\n    }).pipe(\r\n      skip(1) // Skip initial emission\r\n    )\r\n    .subscribe((records: EntityRecord<FeatureWithMeasure>[]) => {\r\n      if (this.modifyControl.active === true) {\r\n        this.deactivateModifyControl();\r\n      }\r\n      this.selectedFeatures$.next(records.map(record => record.entity));\r\n    });\r\n\r\n    this.subscriptions$$.push(this.store.entities$.subscribe(objectsExists => {\r\n      if (objectsExists.find(objectExist => objectExist.geometry.type === 'Polygon')){\r\n        this.hasArea$.next(true);\r\n      } else {\r\n        this.hasArea$.next(false);\r\n      }\r\n\r\n      if (objectsExists.find(objectExist => objectExist.geometry.type === 'LineString')){\r\n        this.hasLine$.next(true);\r\n      } else {\r\n        this.hasLine$.next(false);\r\n      }\r\n    }));\r\n\r\n    this.subscriptions$$.push(this.store.count$.subscribe(cnt => {\r\n      cnt >= 1 ?\r\n        this.store.layer.options.showInLayerList = true :\r\n        this.store.layer.options.showInLayerList = false;\r\n    }));\r\n  }\r\n\r\n  /**\r\n   * Freeze any store, meaning the layer is removed, strategies are deactivated\r\n   * and some listener removed\r\n   * @internal\r\n   */\r\n  private freezeStore() {\r\n    const store = this.store;\r\n    this.selectedFeatures$$.unsubscribe();\r\n    unByKey(this.onFeatureAddedKey);\r\n    unByKey(this.onFeatureRemovedKey);\r\n    store.deactivateStrategyOfType(FeatureStoreLoadingStrategy);\r\n    store.deactivateStrategyOfType(FeatureStoreSelectionStrategy);\r\n  }\r\n\r\n  /**\r\n   * Create a draw line control\r\n   */\r\n  private createDrawLineControl() {\r\n    this.drawLineControl = new DrawControl({\r\n      geometryType: 'LineString',\r\n      drawingLayerSource: this.olDrawSource,\r\n      interactionStyle: createMeasureInteractionStyle(),\r\n      drawingLayerStyle: new OlStyle({})\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Create a draw polygon control\r\n   */\r\n  private createDrawPolygonControl() {\r\n    this.drawPolygonControl = new DrawControl({\r\n      geometryType: 'Polygon',\r\n      drawingLayerSource: this.olDrawSource,\r\n      interactionStyle: createMeasureInteractionStyle(),\r\n      drawingLayerStyle: new OlStyle({})\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Create a draw polygon control\r\n   */\r\n  private createModifyControl() {\r\n    this.modifyControl = new ModifyControl({\r\n      source: this.olDrawSource,\r\n      drawStyle: createMeasureInteractionStyle(),\r\n      layerStyle: new OlStyle({})\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Activate the right control\r\n   */\r\n  private toggleDrawControl() {\r\n    this.deactivateDrawControl();\r\n    // this.deactivateModifyControl();\r\n    if (this.activeMeasureType === MeasureType.Length) {\r\n      this.activateDrawControl(this.drawLineControl);\r\n    } else if (this.activeMeasureType === MeasureType.Area) {\r\n      this.activateDrawControl(this.drawPolygonControl);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Activate a given control\r\n   * @param drawControl Draw control\r\n   */\r\n  private activateDrawControl(drawControl: DrawControl) {\r\n    this.drawControlIsDisabled = false;\r\n    this.activeDrawControl = drawControl;\r\n    this.drawStart$$ = drawControl.start$\r\n      .subscribe((olGeometry: OlLineString | OlPolygon) => this.onDrawStart(olGeometry));\r\n    this.drawEnd$$ = drawControl.end$\r\n      .subscribe((olGeometry: OlLineString | OlPolygon) => this.onDrawEnd(olGeometry));\r\n    this.drawChanges$$ = drawControl.changes$\r\n      .subscribe((olGeometry: OlLineString | OlPolygon) => this.onDrawChanges(olGeometry));\r\n    this.drawChanges$$ = drawControl.abort$\r\n      .subscribe((olGeometry: OlLineString | OlPolygon) => {\r\n        this.clearTooltipsOfOlGeometry(olGeometry);\r\n        this.clearMeasures();\r\n      });\r\n    drawControl.setOlMap(this.map.ol, false);\r\n  }\r\n\r\n  /**\r\n   * Deactivate the active draw control\r\n   */\r\n  private deactivateDrawControl() {\r\n    if (this.activeDrawControl === undefined) {\r\n      return;\r\n    }\r\n\r\n    this.olDrawSource.clear();\r\n    if (this.drawStart$$ !== undefined ) { this.drawStart$$.unsubscribe(); }\r\n    if (this.drawEnd$$ !== undefined ) { this.drawEnd$$.unsubscribe(); }\r\n    if (this.drawChanges$$ !== undefined ) { this.drawChanges$$.unsubscribe(); }\r\n\r\n    this.clearTooltipsOfOlSource(this.olDrawSource);\r\n    if (this.activeOlGeometry !== undefined) {\r\n      this.clearTooltipsOfOlGeometry(this.activeOlGeometry);\r\n    }\r\n    this.activeDrawControl.setOlMap(undefined);\r\n    this.activeDrawControl = undefined;\r\n    this.activeOlGeometry = undefined;\r\n  }\r\n\r\n  private setActiveMeasureType(measureType: MeasureType) {\r\n    this._activeMeasureType = measureType;\r\n    this.clearMeasures();\r\n    this.toggleDrawControl();\r\n  }\r\n\r\n  /**\r\n   * Clear the draw source and track the geometry being drawn\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onDrawStart(olGeometry: OlLineString | OlPolygon) {\r\n    this.activeOlGeometry = olGeometry;\r\n  }\r\n\r\n  /**\r\n   * Clear the draw source and track the geometry being draw\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onDrawEnd(olGeometry: OlLineString | OlPolygon) {\r\n    this.activeOlGeometry = undefined;\r\n    this.finalizeMeasureOfOlGeometry(olGeometry);\r\n    this.addFeatureToStore(olGeometry);\r\n    this.clearTooltipsOfOlGeometry(olGeometry);\r\n    this.olDrawSource.clear(true);\r\n  }\r\n\r\n  /**\r\n   * Update measures observables and map tooltips\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onDrawChanges(olGeometry: OlLineString | OlPolygon) {\r\n    const measure = measureOlGeometry(olGeometry, this.projection);\r\n    this.updateMeasureOfOlGeometry(olGeometry, Object.assign({}, measure, {\r\n      area: undefined // We don't want to display an area tooltip while drawing.\r\n    }));\r\n    this.measure$.next(measure);\r\n  }\r\n\r\n  /**\r\n   * Activate a given control\r\n   * @param modifyControl Modify control\r\n   */\r\n  private activateModifyControl() {\r\n    const selection = this.store.getStrategyOfType(FeatureStoreSelectionStrategy) as FeatureStoreSelectionStrategy;\r\n    selection.deactivate();\r\n    selection.clear();\r\n\r\n    this.modifyStart$$ = this.modifyControl.start$\r\n      .subscribe((olGeometry: OlLineString | OlPolygon) => this.onModifyStart(olGeometry));\r\n    this.modifyEnd$$ = this.modifyControl.end$\r\n      .subscribe((olGeometry: OlLineString | OlPolygon) => this.onModifyEnd(olGeometry));\r\n    this.modifyChanges$$ = this.modifyControl.changes$\r\n      .subscribe((olGeometry: OlLineString | OlPolygon) => this.onModifyChanges(olGeometry));\r\n    this.modifyControl.setOlMap(this.map.ol);\r\n  }\r\n\r\n  /**\r\n   * Deactivate the active modify control\r\n   */\r\n  private deactivateModifyControl() {\r\n    if (this.modifyStart$$ !== undefined ) { this.modifyStart$$.unsubscribe(); }\r\n    if (this.modifyEnd$$ !== undefined ) { this.modifyEnd$$.unsubscribe(); }\r\n    if (this.modifyChanges$$ !== undefined ) { this.modifyChanges$$.unsubscribe(); }\r\n\r\n    if (this.activeOlGeometry !== undefined) {\r\n      if (this.selectedFeatures$.value.length === 1) {\r\n        const localFeature = this.selectedFeatures$.value[0];\r\n        this.addFeatureToStore(this.activeOlGeometry, localFeature);\r\n      }\r\n      this.finalizeMeasureOfOlGeometry(this.activeOlGeometry);\r\n    }\r\n\r\n    this.olDrawSource.clear();\r\n\r\n    this.store.activateStrategyOfType(FeatureStoreSelectionStrategy);\r\n\r\n    this.activeOlGeometry = undefined;\r\n    this.modifyControl.setOlMap(undefined);\r\n  }\r\n\r\n  /**\r\n   * Clear the draw source and track the geometry being drawn\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onModifyStart(olGeometry: OlLineString | OlPolygon) {\r\n    this.onDrawStart(olGeometry);\r\n  }\r\n\r\n  /**\r\n   * Update measures observables and map tooltips\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onModifyChanges(olGeometry: OlLineString | OlPolygon) {\r\n    this.onDrawChanges(olGeometry);\r\n  }\r\n\r\n  /**\r\n   * Clear the draw source and track the geometry being draw\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onModifyEnd(olGeometry: OlLineString | OlPolygon) {\r\n    this.finalizeMeasureOfOlGeometry(olGeometry);\r\n  }\r\n\r\n  private finalizeMeasureOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\r\n    const measure = measureOlGeometry(olGeometry, this.projection);\r\n    this.updateMeasureOfOlGeometry(olGeometry, measure);\r\n  }\r\n\r\n  /**\r\n   * Update measures observables\r\n   * @param olGeometry Ol linestring or polygon\r\n   * @param measure Measure\r\n   */\r\n  private updateMeasureOfOlGeometry(olGeometry: OlLineString | OlPolygon, measure: Measure) {\r\n    olGeometry.setProperties({_measure: measure}, true);\r\n    this.updateTooltipsOfOlGeometry(olGeometry);\r\n  }\r\n\r\n  /**\r\n   * Clear the measures observables\r\n   */\r\n  private clearMeasures() {\r\n    this.measure$.next({});\r\n  }\r\n\r\n  /**\r\n   * Add a feature with measures to the store. The loading stragegy of the store\r\n   * will trigger and add the feature to the map.\r\n   * @internal\r\n   */\r\n  private addFeatureToStore(olGeometry, localFeature?: FeatureWithMeasure) {\r\n    const featureId = localFeature ? localFeature.properties.id : olGeometry.ol_uid;\r\n    const projection = this.map.ol.getView().getProjection();\r\n    const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {\r\n      featureProjection: projection,\r\n      dataProjection: projection\r\n    }) as any;\r\n    this.store.update({\r\n      type: FEATURE,\r\n      geometry,\r\n      projection: projection.getCode(),\r\n      properties: {\r\n        id: featureId,\r\n        measure: olGeometry.get('_measure')\r\n      },\r\n      meta: {\r\n        id: featureId\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Update all the tooltips of an OL geometry\r\n   * @param olGeometry OL Geometry\r\n   * @param lengths Lengths of the OL geometry's segments\r\n   * @param measureUnit Display tooltip measure in those units\r\n   */\r\n  private updateTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\r\n    const measure = olGeometry.get('_measure');\r\n    const lengths = measure.lengths;\r\n    const area = measure.area;\r\n\r\n    const olMidpointsTooltips = updateOlTooltipsAtMidpoints(olGeometry);\r\n    if (lengths.length === olMidpointsTooltips.length) {\r\n      for (let i = 0; i < olMidpointsTooltips.length; i++) {\r\n        const length = lengths[i];\r\n        if (length !== undefined) {\r\n          this.updateOlTooltip(\r\n            olMidpointsTooltips[i],\r\n            metersToUnit(length, this.activeLengthUnit),\r\n            this.activeLengthUnit,\r\n            MeasureType.Length\r\n          );\r\n        }\r\n      }\r\n    }\r\n\r\n    if (area !== undefined) {\r\n      this.updateOlTooltip(\r\n        updateOlTooltipAtCenter(olGeometry),\r\n        squareMetersToUnit(area, this.activeAreaUnit),\r\n        this.activeAreaUnit,\r\n        MeasureType.Area\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Show the map tooltips of a geoemtry\r\n   */\r\n  private showTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\r\n    getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip: OlOverlay | undefined) => {\r\n      if (this.shouldShowTooltip(olTooltip)) {\r\n        this.map.ol.addOverlay(olTooltip);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Clear the tooltips of an OL geometrys\r\n   * @param olGeometry OL geometry with tooltips\r\n   */\r\n  private clearTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\r\n    getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip: OlOverlay | undefined) => {\r\n      if (olTooltip !== undefined && olTooltip.getMap() !== undefined) {\r\n        this.map.ol.removeOverlay(olTooltip);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show the map tooltips of all the geometries of a source\r\n   */\r\n  private updateTooltipsOfOlSource(olSource: OlVectorSource<OlGeometry>) {\r\n    olSource.forEachFeature((olFeature: OlFeature<OlGeometry>) => {\r\n      this.updateTooltipsOfOlGeometry(olFeature.getGeometry() as any);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show the map tooltips of all the geometries of a source\r\n   */\r\n  private showTooltipsOfOlSource(olSource: OlVectorSource<OlGeometry>) {\r\n    olSource.forEachFeature((olFeature: OlFeature<OlGeometry>) => {\r\n      this.showTooltipsOfOlGeometry(olFeature.getGeometry() as any);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Clear the map tooltips\r\n   * @param olDrawSource OL vector source\r\n   */\r\n  private clearTooltipsOfOlSource(olSource: OlVectorSource<OlGeometry>) {\r\n    olSource.forEachFeature((olFeature: OlFeature<OlGeometry>) => {\r\n      const olGeometry = olFeature.getGeometry();\r\n      if (olGeometry !== undefined) {\r\n        this.clearTooltipsOfOlGeometry(olFeature.getGeometry() as any);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Update an OL tooltip properties and inner HTML and add it to the map if possible\r\n   * @param olTooltip OL tooltip\r\n   * @param measure The measure valeu ti display\r\n   * @param measureUnit Display tooltip measure in those units\r\n   */\r\n  private updateOlTooltip(\r\n    olTooltip: OlOverlay,\r\n    measure: number,\r\n    unit: MeasureAreaUnit | MeasureLengthUnit,\r\n    type: MeasureType\r\n  ) {\r\n    olTooltip.setProperties({_measure: measure, _unit: unit, _type: type}, true);\r\n    olTooltip.getElement().innerHTML = this.computeTooltipInnerHTML(olTooltip);\r\n    if (this.shouldShowTooltip(olTooltip)) {\r\n      this.map.ol.addOverlay(olTooltip);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Compute a tooltip's content\r\n   * @param olTooltip OL overlay\r\n   * @returns Inner HTML\r\n   */\r\n  private computeTooltipInnerHTML(olTooltip: OlOverlay): string {\r\n    const properties = olTooltip.getProperties() as any;\r\n    return formatMeasure(properties._measure, {\r\n      decimal: 1,\r\n      unit: properties._unit,\r\n      unitAbbr: true,\r\n      locale: 'fr'\r\n    }, this.languageService);\r\n  }\r\n\r\n  /**\r\n   * Whether a tooltip should be showned based on the length\r\n   * of the segment it is bound to.\r\n   * @param olTooltip OL overlay\r\n   * @returns True if the tooltip should be shown\r\n   */\r\n  private shouldShowTooltip(olTooltip: OlOverlay): boolean {\r\n    if (this.showTooltips === false) {\r\n      return false;\r\n    }\r\n\r\n    const properties = olTooltip.getProperties() as any;\r\n    const measure = properties._measure;\r\n    if (measure === undefined) {\r\n      return false;\r\n    }\r\n\r\n    if (properties._unit === MeasureType.Length) {\r\n      const minSegmentLength = metersToUnit(this.minSegmentLength, properties._unit) || 0;\r\n      return measure > Math.max(minSegmentLength, 0);\r\n    }\r\n\r\n    return true;\r\n  }\r\n}\r\n","<div>\r\n  <div class=\"measure-type-toggle mat-typography\">\r\n    <mat-button-toggle-group\r\n      [value]=\"activeMeasureType\"\r\n      (change)=\"onMeasureTypeChange($event.value)\">\r\n      <mat-button-toggle [value]=\"measureType.Length\">\r\n        {{('igo.geo.measure.' + measureType.Length) | translate}}\r\n      </mat-button-toggle>\r\n      <mat-button-toggle [value]=\"measureType.Area\">\r\n        {{('igo.geo.measure.' + measureType.Area) | translate}}\r\n      </mat-button-toggle>\r\n    </mat-button-toggle-group>\r\n  </div>\r\n\r\n  <div class=\"measure-options mat-typography\">\r\n    <mat-slide-toggle\r\n      [disabled]=\"drawControlIsDisabled\"\r\n      [checked]=\"drawControlIsActive\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDrawControl($event.checked)\">\r\n      {{'igo.geo.measure.toggleActive' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-divider *ngIf=\"(hasLine$ | async)\"></mat-divider>\r\n\r\n    <mat-slide-toggle *ngIf=\"(hasLine$ | async)\"\r\n      [checked]=\"displayLines\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDisplayLines($event.checked)\">\r\n      {{'igo.geo.measure.toggleDisplayLines' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\r\n\r\n    <mat-slide-toggle *ngIf=\"(hasArea$ | async)\"\r\n      [checked]=\"displayDistance\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDisplayDistance($event.checked)\">\r\n      {{'igo.geo.measure.toggleDisplayDistance' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-slide-toggle *ngIf=\"(hasArea$ | async)\"\r\n      [checked]=\"displayAreas\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleDisplayAreas($event.checked)\">\r\n      {{'igo.geo.measure.toggleDisplayAreas' | translate}}\r\n    </mat-slide-toggle>\r\n\r\n    <mat-divider *ngIf=\"(hasArea$ | async)\"></mat-divider>\r\n\r\n    <mat-slide-toggle\r\n      [checked]=\"measureUnitsAuto\"\r\n      [labelPosition]=\"'before'\"\r\n      (change)=\"onToggleMeasureUnitsAuto($event.checked)\">\r\n      {{'igo.geo.measure.toggleAutoUnits' | translate}}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <ng-container *ngIf=\"measure$ | async as measure\">\r\n    <igo-measurer-item *ngIf=\"activeMeasureType === measureType.Length || activeMeasureType === measureType.Area\"\r\n      [measureType]=\"measureType.Length\"\r\n      [measureUnit]=\"measureLengthUnit.Meters\"\r\n      [measure]=\"measure.length\"\r\n      [auto]=\"measureUnitsAuto\"\r\n      [placeholder]=\"(activeMeasureType === measureType.Area ? 'igo.geo.measure.perimeter' : 'igo.geo.measure.length') | translate\"\r\n      (measureUnitChange)=\"onLengthUnitChange($event)\">\r\n    </igo-measurer-item>\r\n\r\n    <igo-measurer-item *ngIf=\"activeMeasureType === measureType.Area\"\r\n      [measureType]=\"measureType.Area\"\r\n      [measureUnit]=\"measureAreaUnit.SquareMeters\"\r\n      [measure]=\"measure.area\"\r\n      [auto]=\"measureUnitsAuto\"\r\n      [placeholder]=\"'igo.geo.measure.area' | translate\"\r\n      (measureUnitChange)=\"onAreaUnitChange($event)\">\r\n    </igo-measurer-item>\r\n  </ng-container>\r\n\r\n  <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\r\n\r\n  <div class=\"measure-store-buttons\">\r\n    <button *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\r\n      mat-icon-button\r\n      [matTooltip]=\"'igo.geo.measure.actionbar.calculate.tooltip' | translate\"\r\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\r\n      color=\"accent\"\r\n      (click)=\"onCalculateClick()\">\r\n      <mat-icon svgIcon=\"calculator\"></mat-icon>\r\n    </button>\r\n\r\n    <button *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\r\n      mat-icon-button\r\n      [matTooltip]=\"'igo.geo.measure.actionbar.delete.tooltip' | translate\"\r\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\r\n      color=\"warn\"\r\n      (click)=\"onDeleteClick()\">\r\n      <mat-icon svgIcon=\"delete\"></mat-icon>\r\n    </button>\r\n\r\n    <!--button\r\n      mat-icon-button\r\n      [matTooltip]=\"'igo.geo.measure.actionbar.modify.tooltip' | translate\"\r\n      [disabled]=\"(selectedFeatures$ | async).length !== 1\"\r\n      (click)=\"onModifyClick()\">\r\n      <mat-icon svgIcon=\"edit\"></mat-icon>\r\n    </button-->\r\n  </div>\r\n\r\n  <igo-entity-table\r\n    #table\r\n    class=\"table-compact\"\r\n    [store]=\"store\"\r\n    [template]=\"tableTemplate\">\r\n  </igo-entity-table>\r\n</div>\r\n"]}