@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/draw/draw/draw.component.mjs

@@ -0,0 +1,1369 @@
+import { Component, Input, ChangeDetectionStrategy, Output, EventEmitter, ViewChild } from '@angular/core';
+import { FEATURE, FeatureStore, FeatureStoreSelectionStrategy, tryAddLoadingStrategy, tryAddSelectionStrategy, FeatureMotion, FeatureStoreLoadingStrategy, featureToOl } from '../../feature';
+import { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';
+import { LanguageService } from '@igo2/core';
+import { MatDialog } from '@angular/material/dialog';
+import { GeometryType, LabelType } from '../shared/draw.enum';
+import { FontType } from '../../style/shared/font.enum';
+import { IgoMap } from '../../map/shared/map';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { UntypedFormBuilder, UntypedFormControl } from '@angular/forms';
+import { VectorLayer } from '../../layer/shared/layers/vector-layer';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { DrawControl } from '../../geometry/shared/controls/draw';
+import { EntityTableColumnRenderer } from '@igo2/common';
+import * as OlStyle from 'ol/style';
+import * as olproj from 'ol/proj';
+import OlVectorSource from 'ol/source/Vector';
+import OlCircle from 'ol/geom/Circle';
+import OlPoint from 'ol/geom/Point';
+import OlFeature from 'ol/Feature';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import { getDistance, getLength } from 'ol/sphere';
+import { DrawStyleService } from '../../style/style-service/draw-style.service';
+import { first, skip } from 'rxjs/operators';
+import { DrawPopupComponent } from './draw-popup.component';
+import { DrawShorcutsComponent } from './draw-shorcuts.component';
+import { getTooltipsOfOlGeometry } from '../../measure/shared/measure.utils';
+import { createInteractionStyle, DDtoDMS } from '../shared/draw.utils';
+import { transform } from 'ol/proj';
+import { DrawIconService } from '../shared/draw-icon.service';
+import { StyleModalDrawingComponent } from '../../style/style-modal/drawing/style-modal-drawing.component';
+import { trigger, state, style, animate, transition } from '@angular/animations';
+import { DrawLayerPopupComponent } from './draw-layer-popup.component';
+import { measureOlGeometryLength, measureOlGeometryArea, metersToUnit, squareMetersToUnit } from '../../measure/shared/measure.utils';
+import { MeasureLengthUnit, MeasureLengthUnitAbbreviation, MeasureAreaUnitAbbreviation } from '../../measure/shared/measure.enum';
+import Polygon, { fromCircle } from 'ol/geom/Polygon';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "@angular/forms";
+import * as i3 from "../../style/style-service/draw-style.service";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "../shared/draw-icon.service";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/button-toggle";
+import * as i9 from "@angular/material/divider";
+import * as i10 from "@angular/material/form-field";
+import * as i11 from "@angular/material/icon";
+import * as i12 from "@angular/material/badge";
+import * as i13 from "@angular/material/tooltip";
+import * as i14 from "@angular/material/input";
+import * as i15 from "@angular/material/select";
+import * as i16 from "@angular/material/core";
+import * as i17 from "@angular/material/slide-toggle";
+import * as i18 from "@igo2/common";
+import * as i19 from "@ngx-translate/core";
+const _c0 = ["selectedLayer"];
+function DrawComponent_mat_slide_toggle_22_Template(rf, ctx) { if (rf & 1) {
+    const _r10 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 5);
+    i0.ɵɵlistener("change", function DrawComponent_mat_slide_toggle_22_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r10); const ctx_r9 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r9.onToggleFreehandMode($event)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("checked", ctx_r0.freehandMode)("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 3, "igo.geo.draw.freehandMode"), " ");
+} }
+function DrawComponent_div_23_mat_option_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 2);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const measureUnit_r12 = ctx.$implicit;
+    i0.ɵɵproperty("value", measureUnit_r12);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 2, "igo.geo.measure." + measureUnit_r12), " ");
+} }
+function DrawComponent_div_23_Template(rf, ctx) { if (rf & 1) {
+    const _r14 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 24)(1, "form", 25)(2, "mat-form-field", 26);
+    i0.ɵɵelement(3, "input", 27);
+    i0.ɵɵpipe(4, "translate");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(5, "mat-form-field", 28)(6, "mat-select", 10);
+    i0.ɵɵlistener("selectionChange", function DrawComponent_div_23_Template_mat_select_selectionChange_6_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r13 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r13.onMeasureUnitChange($event.value)); });
+    i0.ɵɵtemplate(7, DrawComponent_div_23_mat_option_7_Template, 3, 4, "mat-option", 12);
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(3);
+    i0.ɵɵpropertyInterpolate("placeholder", i0.ɵɵpipeBind1(4, 5, "igo.geo.spatialFilter.radius"));
+    i0.ɵɵproperty("formControl", ctx_r1.radiusFormControl)("readonly", ctx_r1.freehandMode);
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("value", ctx_r1.measureUnit);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", ctx_r1.measureUnits);
+} }
+function DrawComponent_mat_option_32_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 2);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const layer_r15 = ctx.$implicit;
+    i0.ɵɵproperty("value", layer_r15);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", layer_r15.title, " ");
+} }
+function DrawComponent_button_36_Template(rf, ctx) { if (rf & 1) {
+    const _r17 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 29);
+    i0.ɵɵlistener("click", function DrawComponent_button_36_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r17); const ctx_r16 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r16.activeDrawingLayer.visible = !ctx_r16.activeDrawingLayer.visible); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelement(3, "mat-icon", 30);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r4 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("color", ctx_r4.activeDrawingLayer.visible ? "primary" : "default")("matTooltip", ctx_r4.activeDrawingLayer.visible ? i0.ɵɵpipeBind1(1, 3, "igo.geo.layer.hideLayer") : i0.ɵɵpipeBind1(2, 5, "igo.geo.layer.showLayer"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("svgIcon", ctx_r4.activeDrawingLayer.visible ? "eye" : "eye-off");
+} }
+function DrawComponent_button_39_Template(rf, ctx) { if (rf & 1) {
+    const _r19 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 31);
+    i0.ɵɵlistener("click", function DrawComponent_button_39_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r19); const ctx_r18 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r18.deleteDrawings()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelement(3, "mat-icon", 32);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r5 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.geo.draw.delete"))("disabled", i0.ɵɵpipeBind1(2, 4, ctx_r5.selectedFeatures$).length === 0);
+} }
+function DrawComponent_mat_form_field_44_div_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 36);
+    i0.ɵɵelement(1, "img", 37);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r20 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵpropertyInterpolate("src", ctx_r20.icon, i0.ɵɵsanitizeUrl);
+} }
+function DrawComponent_mat_form_field_44_mat_option_10_Template(rf, ctx) { if (rf & 1) {
+    const _r24 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-option", 38);
+    i0.ɵɵlistener("click", function DrawComponent_mat_form_field_44_mat_option_10_Template_mat_option_click_0_listener() { const restoredCtx = i0.ɵɵrestoreView(_r24); const icon_html_r22 = restoredCtx.$implicit; const ctx_r23 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r23.onIconChange(icon_html_r22)); });
+    i0.ɵɵelementStart(1, "div", 36);
+    i0.ɵɵelement(2, "img", 37);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const icon_html_r22 = ctx.$implicit;
+    i0.ɵɵproperty("value", icon_html_r22);
+    i0.ɵɵadvance(2);
+    i0.ɵɵpropertyInterpolate("src", icon_html_r22, i0.ɵɵsanitizeUrl);
+} }
+function DrawComponent_mat_form_field_44_Template(rf, ctx) { if (rf & 1) {
+    const _r26 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-form-field")(1, "mat-label");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "mat-select")(5, "mat-select-trigger");
+    i0.ɵɵtemplate(6, DrawComponent_mat_form_field_44_div_6_Template, 2, 1, "div", 33);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(7, "mat-option", 34);
+    i0.ɵɵlistener("click", function DrawComponent_mat_form_field_44_Template_mat_option_click_7_listener() { i0.ɵɵrestoreView(_r26); const ctx_r25 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r25.onIconChange()); });
+    i0.ɵɵtext(8);
+    i0.ɵɵpipe(9, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(10, DrawComponent_mat_form_field_44_mat_option_10_Template, 3, 2, "mat-option", 35);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r7 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 4, "igo.geo.draw.icon"));
+    i0.ɵɵadvance(4);
+    i0.ɵɵproperty("ngIf", ctx_r7.icon);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(9, 6, "igo.geo.draw.noIcon"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngForOf", ctx_r7.icons);
+} }
+function DrawComponent_button_49_Template(rf, ctx) { if (rf & 1) {
+    const _r28 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 39);
+    i0.ɵɵlistener("click", function DrawComponent_button_49_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r28); const ctx_r27 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r27.openStyleModalDialog()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelement(4, "mat-icon", 40);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r8 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 3, "igo.geo.style.styleModalTooltipSelected"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 5, "igo.geo.style.styleModal"), " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("matBadge", ctx_r8.selectedFeatures$.value.length);
+} }
+export class DrawComponent {
+    languageService;
+    formBuilder;
+    drawStyleService;
+    dialog;
+    drawIconService;
+    /**
+     * Table template
+     * @internal
+     */
+    tableTemplate;
+    geometryType = GeometryType; // Reference to the GeometryType enum
+    map; // Map to draw on
+    get stores() {
+        return this._stores;
+    }
+    set stores(value) {
+        this._stores = value;
+    }
+    _stores = [];
+    get drawControls() {
+        return this._drawControls;
+    }
+    set drawControls(value) {
+        this._drawControls = value;
+    }
+    _drawControls = [];
+    get activeDrawingLayer() {
+        return this._activeDrawingLayer;
+    }
+    set activeDrawingLayer(value) {
+        this._activeDrawingLayer = value;
+    }
+    _activeDrawingLayer;
+    activeLayerChange = new EventEmitter();
+    drawControlsEvent = new EventEmitter();
+    layersIDEvent = new EventEmitter();
+    fillColor;
+    strokeColor;
+    strokeWidth;
+    fontSize;
+    fontStyle;
+    activeStore;
+    layerCounterID = 0;
+    draw$ = new BehaviorSubject({}); // Observable of draw
+    activeDrawingLayerSource = new OlVectorSource();
+    activeDrawControl;
+    drawEnd$$;
+    drawSelect$$;
+    selectedFeatures$ = new BehaviorSubject([]);
+    fillForm;
+    strokeForm;
+    drawControlIsDisabled = true;
+    drawControlIsActive = false;
+    labelsAreShown;
+    freehandMode = false;
+    subscriptions$$ = [];
+    position = 'bottom';
+    form;
+    icons;
+    icon;
+    radiusFormControl = new UntypedFormControl(1000);
+    measureUnit = MeasureLengthUnit.Meters;
+    radiusFormControlChange$$ = new Subscription();
+    predefinedRadius$ = new BehaviorSubject(undefined);
+    radiusDrawEnd$ = new BehaviorSubject(undefined);
+    /**
+     * Available measure units for the measure type given
+     * @internal
+     */
+    get measureUnits() {
+        return [MeasureLengthUnit.Meters, MeasureLengthUnit.Kilometers];
+    }
+    numberOfDrawings;
+    isCreatingNewLayer = false;
+    currGeometryType = this.geometryType.Point;
+    select;
+    constructor(languageService, formBuilder, drawStyleService, dialog, drawIconService) {
+        this.languageService = languageService;
+        this.formBuilder = formBuilder;
+        this.drawStyleService = drawStyleService;
+        this.dialog = dialog;
+        this.drawIconService = drawIconService;
+        this.tableTemplate = {
+            selection: true,
+            selectMany: true,
+            selectionCheckbox: true,
+            sort: true,
+            fixedHeader: true,
+            tableHeight: 'auto',
+            columns: [
+                {
+                    name: 'Drawing',
+                    title: this.languageService.translate.instant('igo.geo.draw.labels'),
+                    valueAccessor: (feature) => {
+                        return feature.properties.draw;
+                    }
+                },
+                {
+                    name: 'Edition',
+                    title: '',
+                    sort: false,
+                    valueAccessor: (feature) => {
+                        return [
+                            {
+                                editMode: false,
+                                icon: 'pencil',
+                                color: 'primary',
+                                click: () => {
+                                    this.editLabelDrawing(feature);
+                                },
+                                style: 'mat-icon-button'
+                            }
+                        ];
+                    },
+                    renderer: EntityTableColumnRenderer.ButtonGroup
+                }
+            ]
+        };
+        this.buildForm();
+        this.fillColor = this.drawStyleService.getFillColor();
+        this.strokeColor = this.drawStyleService.getStrokeColor();
+        this.strokeWidth = this.drawStyleService.getStrokeWidth();
+        this.labelsAreShown = this.drawStyleService.getLabelsAreShown();
+        this.icons = this.drawIconService.getIcons();
+        this.icon = this.drawStyleService.getIcon();
+        this.fontSize = this.drawStyleService.getFontSize();
+        this.fontStyle = this.drawStyleService.getFontStyle();
+    }
+    // Initialize the store that will contain the entities and create the Draw control
+    ngOnInit() {
+        if (!this.stores.length) {
+            this.activeStore = new FeatureStore([], {
+                map: this.map
+            });
+            this.initStore();
+            this.activeDrawControl = this.createDrawControl(this.fillColor, this.strokeColor, this.strokeWidth);
+            this.activeDrawControl.setGeometryType(this.geometryType.Point);
+            this.toggleDrawControl();
+            this.stores.push(this.activeStore);
+            this.drawControls.push([
+                this.activeDrawingLayer.id,
+                this.activeDrawControl
+            ]);
+            this.drawControlsEvent.emit(this.drawControls);
+            this.layersIDEvent.emit(this.activeDrawingLayer.id);
+            this.onLayerChange(this.activeDrawingLayer);
+        }
+        else {
+            this.activeStore = this.stores.find((store) => store.layer.id === this.activeDrawingLayer.id);
+            this.activeDrawControl = this.drawControls.find((dc) => dc[0] === this.activeDrawingLayer.id)[1];
+            this.deactivateDrawControl();
+            this.allLayers.forEach((layer) => {
+                if (layer.id !== this.activeDrawingLayer.id) {
+                    layer.opacity = 0;
+                }
+                let store = this.stores.find((s) => s.layer.id === layer.id);
+                this.subscriptions$$.push(store.stateView
+                    .manyBy$((record) => {
+                    return record.state.selected === true;
+                })
+                    .pipe(first())
+                    .subscribe((records) => {
+                    records.forEach((record) => {
+                        record.state.selected = false;
+                    });
+                }));
+                this.subscriptions$$.push(store.stateView
+                    .manyBy$((record) => {
+                    return record.state.selected === true;
+                })
+                    .pipe(skip(1) // Skip initial emission
+                )
+                    .subscribe((records) => {
+                    this.selectedFeatures$.next(records.map((record) => record.entity));
+                }));
+                this.subscriptions$$.push(store.count$.subscribe((cnt) => {
+                    cnt >= 1
+                        ? (this.activeStore.layer.options.showInLayerList = true)
+                        : (this.activeStore.layer.options.showInLayerList = false);
+                }));
+            });
+            this.onLayerChange(this.activeDrawingLayer);
+        }
+        this.radiusFormControlChange$$ =
+            this.radiusFormControl.valueChanges.subscribe((value) => {
+                if (this.activeDrawControl.ispredefinedRadius$.getValue()) {
+                    this.changeRadius(value);
+                }
+            });
+    }
+    /**
+     * Remove the drawing layer and the interactions
+     * @internal
+     */
+    ngOnDestroy() {
+        this.allLayers.forEach((layer) => (layer.opacity = 1));
+        this.activeStore.state.updateAll({ selected: false });
+        this.deactivateDrawControl();
+        this.subscriptions$$.map((s) => s.unsubscribe());
+        this.radiusFormControlChange$$.unsubscribe();
+    }
+    /**
+     * Create a Draw Control
+     * @param fillColor the fill color
+     * @param strokeColor the stroke color
+     * @param strokeWidth the stroke width
+     * @returns a Draw Control
+     */
+    createDrawControl(fillColor, strokeColor, strokeWidth) {
+        const activeDrawControl = new DrawControl({
+            geometryType: undefined,
+            drawingLayerSource: this.activeDrawingLayerSource,
+            drawingLayerStyle: new OlStyle.Style({}),
+            interactionStyle: createInteractionStyle(fillColor, strokeColor, strokeWidth)
+        });
+        return activeDrawControl;
+    }
+    /**
+     * Store initialization, including drawing layer creation
+     */
+    initStore(newTitle, isNewLayer) {
+        this.createLayer(newTitle, isNewLayer);
+        this.subscriptions$$.push(this.activeStore.stateView
+            .manyBy$((record) => {
+            return record.state.selected === true;
+        })
+            .pipe(skip(1) // Skip initial emission
+        )
+            .subscribe((records) => {
+            this.selectedFeatures$.next(records.map((record) => record.entity));
+        }));
+        this.subscriptions$$.push(this.activeStore.count$.subscribe((cnt) => {
+            cnt >= 1
+                ? (this.activeStore.layer.options.showInLayerList = true)
+                : (this.activeStore.layer.options.showInLayerList = false);
+        }));
+    }
+    /**
+     * Open the style modal dialog box
+     */
+    openStyleModalDialog() {
+        setTimeout(() => {
+            // open the dialog box used to style features
+            const dialogRef = this.dialog.open(StyleModalDrawingComponent, {
+                disableClose: false,
+                data: {
+                    features: this.selectedFeatures$.getValue(),
+                    icons: this.icons,
+                    icon: this.icon
+                },
+                autoFocus: false
+            });
+            // when dialog box is closed, get label and set it to geometry
+            dialogRef.afterClosed().subscribe((data) => {
+                // checks if the user clicked ok
+                if (dialogRef.componentInstance.confirmFlag) {
+                    this.onFontChange(this.labelsAreShown, data.fontSize, data.fontStyle);
+                    this.onColorChange(this.labelsAreShown, this.icon ? true : false, data.fillColor, data.strokeColor);
+                    this.onOffsetLabelChange(this.labelsAreShown, data.offsetX, data.offsetY);
+                }
+            });
+        }, 250);
+    }
+    /**
+     * Open a dialog box to enter label and do something
+     * @param olGeometry geometry at draw end or selected geometry
+     * @param drawEnd event fired at drawEnd?
+     */
+    openDrawDialog(olGeometry, isDrawEnd) {
+        setTimeout(() => {
+            // open the dialog box used to enter label
+            const dialogRef = this.dialog.open(DrawPopupComponent, {
+                disableClose: false,
+                data: { olGeometry: olGeometry, map: this.map }
+            });
+            // when dialog box is closed, get label and set it to geometry
+            dialogRef.afterClosed().subscribe((result) => {
+                // checks if the user clicked ok
+                if (dialogRef.componentInstance.confirmFlag) {
+                    this.updateLabelOfOlGeometry(olGeometry, result.label);
+                    this.updateLabelType(olGeometry, dialogRef.componentInstance.labelFlag);
+                    this.updateMeasureUnit(olGeometry, result.measureUnit);
+                    if (!(olGeometry instanceof OlFeature)) {
+                        this.updateFontSizeAndStyle(olGeometry, '15', FontType.Arial);
+                        this.updateFillAndStrokeColor(olGeometry, 'rgba(255,255,255,0.4)', 'rgba(143,7,7,1)');
+                        this.updateOffset(olGeometry, 0, olGeometry instanceof OlPoint ? -15 : 0);
+                    }
+                    isDrawEnd
+                        ? this.onDrawEnd(olGeometry)
+                        : this.onSelectDraw(olGeometry, result.label, [
+                            dialogRef.componentInstance.labelFlag,
+                            result.measureUnit
+                        ]);
+                    this.updateHeightTable();
+                }
+                // deletes the feature
+                else {
+                    this.activeDrawingLayerSource
+                        .getFeatures()
+                        .forEach((drawingLayerFeature) => {
+                        const geometry = drawingLayerFeature.getGeometry();
+                        if (olGeometry === geometry) {
+                            this.activeDrawingLayerSource.removeFeature(drawingLayerFeature);
+                        }
+                    });
+                }
+            });
+        }, 250);
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawEnd(olGeometry, radius) {
+        this.addFeatureToStore(olGeometry, radius);
+        this.clearLabelsOfOlGeometry(olGeometry);
+        this.activeStore.layer.ol.getSource().refresh();
+    }
+    onModifyDraw(olGeometry) {
+        const entities = this.activeStore.all();
+        entities.forEach((entity) => {
+            const entityId = entity.properties.id;
+            const olGeometryId = olGeometry.ol_uid;
+            if (entityId === olGeometryId) {
+                if (entity.properties.labelType === LabelType.Coordinates) {
+                    let longLat = DDtoDMS([entity.properties.longitude, entity.properties.latitude], entity.properties.measureUnit);
+                    this.updateLabelOfOlGeometry(olGeometry, '(' + longLat[1] + ', ' + longLat[0] + ')');
+                }
+                else if (entity.properties.labelType === LabelType.Length) {
+                    if (olGeometry instanceof OlCircle) {
+                        let circularPolygon = fromCircle(olGeometry, 10000);
+                        const radius = metersToUnit(this.getRadius(circularPolygon), entity.properties.measureUnit);
+                        const unit = MeasureLengthUnitAbbreviation[entity.properties.measureUnit];
+                        const radiusLabel = 'R: ' + radius.toFixed(2).toString() + ' ' + unit;
+                        this.updateLabelOfOlGeometry(olGeometry, radiusLabel);
+                    }
+                    else {
+                        let olGeometryLength = measureOlGeometryLength(olGeometry, this.map.ol.getView().getProjection().getCode());
+                        let measureUnit;
+                        const temp = entity.properties
+                            .measureUnit;
+                        measureUnit =
+                            MeasureLengthUnitAbbreviation[entity.properties.measureUnit];
+                        olGeometryLength = metersToUnit(olGeometryLength, temp);
+                        let lengthLabel = olGeometry instanceof Polygon
+                            ? 'P: ' +
+                                olGeometryLength.toFixed(2).toString() +
+                                ' ' +
+                                measureUnit
+                            : olGeometryLength.toFixed(2).toString() + ' ' + measureUnit;
+                        this.updateLabelOfOlGeometry(olGeometry, lengthLabel);
+                    }
+                }
+                else if (entity.properties.labelType === LabelType.Area) {
+                    if (olGeometry instanceof OlCircle) {
+                        let circularPolygon = fromCircle(olGeometry, 10000);
+                        let circleArea = measureOlGeometryArea(circularPolygon, this.map.ol.getView().getProjection().getCode());
+                        const unit = MeasureAreaUnitAbbreviation[entity.properties.measureUnit];
+                        const temp = entity.properties
+                            .measureUnit;
+                        circleArea = squareMetersToUnit(circleArea, temp);
+                        const areaLabel = circleArea.toFixed(2).toString() + ' ' + unit;
+                        this.updateLabelOfOlGeometry(olGeometry, areaLabel);
+                    }
+                    else {
+                        let olGeometryArea = measureOlGeometryArea(olGeometry, this.map.ol.getView().getProjection().getCode());
+                        let measureUnit;
+                        const temp = entity.properties
+                            .measureUnit;
+                        measureUnit =
+                            MeasureAreaUnitAbbreviation[entity.properties.measureUnit];
+                        olGeometryArea = squareMetersToUnit(olGeometryArea, temp);
+                        const lengthLabel = olGeometryArea.toFixed(2).toString() + ' ' + measureUnit;
+                        this.updateLabelOfOlGeometry(olGeometry, lengthLabel);
+                    }
+                }
+                else {
+                    this.updateLabelOfOlGeometry(olGeometry, entity.properties.draw);
+                }
+                this.updateLabelType(olGeometry, entity.properties.labelType);
+                this.updateMeasureUnit(olGeometry, entity.properties.measureUnit);
+                this.updateFontSizeAndStyle(olGeometry, entity.properties.fontStyle.split(' ')[0].replace('px', ''), entity.properties.fontStyle.substring(entity.properties.fontStyle.indexOf(' ') + 1));
+                this.updateFillAndStrokeColor(olGeometry, entity.properties.drawingStyle.fill, entity.properties.drawingStyle.stroke);
+                this.updateOffset(olGeometry, entity.properties.offsetX, entity.properties.offsetY);
+                this.replaceFeatureInStore(entity, olGeometry);
+            }
+        });
+    }
+    onSelectDraw(olFeature, label, labelTypeAndUnit) {
+        const entities = this.activeStore.all();
+        const olGeometry = olFeature.getGeometry();
+        olGeometry.ol_uid = olFeature.get('id');
+        const olGeometryCoordinates = JSON.stringify(olGeometry.getCoordinates()[0]);
+        entities.forEach((entity) => {
+            const entityCoordinates = JSON.stringify(entity.geometry.coordinates[0]);
+            if (olGeometryCoordinates === entityCoordinates) {
+                const fontSize = olFeature
+                    .get('fontStyle')
+                    .split(' ')[0]
+                    .replace('px', '');
+                const fontStyle = olFeature
+                    .get('fontStyle')
+                    .substring(olFeature.get('fontStyle').indexOf(' ') + 1);
+                const fillColor = olFeature.get('drawingStyle').fill;
+                const strokeColor = olFeature.get('drawingStyle').stroke;
+                const offsetX = olFeature.get('offsetX');
+                const offsetY = olFeature.get('offsetY');
+                const rad = entity.properties.rad
+                    ? entity.properties.rad
+                    : undefined;
+                this.updateLabelOfOlGeometry(olGeometry, label);
+                this.updateFontSizeAndStyle(olGeometry, fontSize, fontStyle);
+                this.updateFillAndStrokeColor(olGeometry, fillColor, strokeColor);
+                this.updateOffset(olGeometry, offsetX, offsetY);
+                this.updateLabelType(olGeometry, labelTypeAndUnit[0]);
+                this.updateMeasureUnit(olGeometry, labelTypeAndUnit[1]);
+                this.replaceFeatureInStore(entity, olGeometry, rad);
+            }
+        });
+    }
+    /**
+     * Add a feature with draw label to the store. The loading stragegy of the store
+     * will trigger and add the feature to the map.
+     * @internal
+     */
+    addFeatureToStore(olGeometry, radius, feature) {
+        let rad;
+        let center4326;
+        let point4326;
+        let lon4326;
+        let lat4326;
+        const featureId = feature ? feature.properties.id : olGeometry.ol_uid;
+        const projection = this.map.ol.getView().getProjection();
+        const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {
+            featureProjection: projection,
+            dataProjection: projection
+        });
+        if (olGeometry instanceof OlCircle || radius) {
+            if (radius) {
+                rad = radius;
+            }
+            else {
+                geometry.type = 'Point';
+                geometry.coordinates = olGeometry.getCenter();
+                const extent4326 = transform([
+                    olGeometry.getFlatCoordinates()[2],
+                    olGeometry.getFlatCoordinates()[3]
+                ], projection, 'EPSG:4326');
+                center4326 = transform([
+                    olGeometry.getFlatCoordinates()[0],
+                    olGeometry.getFlatCoordinates()[1]
+                ], projection, 'EPSG:4326');
+                lon4326 = center4326[0];
+                lat4326 = center4326[1];
+                rad = getDistance(center4326, extent4326);
+                this.radiusFormControl.setValue(Math.round(rad));
+            }
+        }
+        if (this.activeDrawControl.radiusDrawEnd$.getValue()) {
+            rad = this.activeDrawControl.radiusDrawEnd$.getValue();
+        }
+        if (olGeometry instanceof OlPoint) {
+            point4326 = transform(olGeometry.getFlatCoordinates(), projection, 'EPSG:4326');
+            lon4326 = point4326[0];
+            lat4326 = point4326[1];
+        }
+        this.activeStore.update({
+            type: FEATURE,
+            geometry,
+            projection: projection.getCode(),
+            properties: {
+                id: featureId,
+                draw: olGeometry.get('_label'),
+                longitude: lon4326 ? lon4326 : null,
+                latitude: lat4326 ? lat4326 : null,
+                rad: rad ? rad : null,
+                fontStyle: olGeometry.get('fontStyle_'),
+                drawingStyle: {
+                    fill: olGeometry.get('fillColor_'),
+                    stroke: olGeometry.get('strokeColor_')
+                },
+                offsetX: olGeometry.get('offsetX_'),
+                offsetY: olGeometry.get('offsetY_'),
+                labelType: olGeometry.get('labelType_'),
+                measureUnit: olGeometry.get('measureUnit_')
+            },
+            meta: {
+                id: featureId
+            }
+        });
+        this.activeStore.setLayerExtent();
+        this.activeDrawControl.predefinedRadius$.next(undefined);
+        this.activeDrawControl.radiusDrawEnd$.next(undefined);
+    }
+    buildForm() {
+        this.form = this.formBuilder.group({
+            fill: [''],
+            stroke: ['']
+        });
+    }
+    setupLayer(isNewLayer) {
+        setTimeout(() => {
+            const dialogRef = this.dialog.open(DrawLayerPopupComponent, {
+                disableClose: false
+            });
+            dialogRef.afterClosed().subscribe((label) => {
+                if (dialogRef.componentInstance.confirmFlag) {
+                    this.activeStore.state.updateAll({ selected: false });
+                    this.activeStore = new FeatureStore([], {
+                        map: this.map
+                    });
+                    this.activeDrawingLayerSource = new OlVectorSource();
+                    this.activeDrawingLayer.opacity = 0;
+                    this.deactivateDrawControl();
+                    this.initStore(label, isNewLayer);
+                    this.activeDrawControl = this.createDrawControl(this.fillColor, this.strokeColor, this.strokeWidth);
+                    this.activeDrawControl.setGeometryType(this.currGeometryType);
+                    this.toggleDrawControl();
+                    this.stores.push(this.activeStore);
+                    this.drawControls.push([
+                        this.activeDrawingLayer.id,
+                        this.activeDrawControl
+                    ]);
+                    this.drawControlsEvent.emit(this.drawControls);
+                    this.layersIDEvent.emit(this.activeDrawingLayer.id);
+                    this.isCreatingNewLayer = false;
+                    if (!this.labelsAreShown) {
+                        this.onToggleLabels();
+                    }
+                    this.activeLayerChange.emit(this.activeDrawingLayer);
+                }
+                else {
+                    this.select.value = this.activeDrawingLayer;
+                    this.select.selectionChange.emit(this.activeDrawingLayer);
+                }
+            });
+        }, 250);
+    }
+    // HTML user interactions
+    /**
+     * Called when the user double-clicks the selected drawing
+     */
+    editLabelDrawing(feature) {
+        const olGeometryFeature = featureToOl(feature, this.map.ol.getView().getProjection().getCode());
+        this.openDrawDialog(olGeometryFeature, false);
+    }
+    openShorcutsDialog() {
+        this.dialog.open(DrawShorcutsComponent);
+    }
+    deleteDrawings() {
+        this.activeStore.deleteMany(this.selectedFeatures$.value);
+        this.selectedFeatures$.value.forEach((selectedFeature) => {
+            this.activeDrawingLayerSource
+                .getFeatures()
+                .forEach((drawingLayerFeature) => {
+                const geometry = drawingLayerFeature.getGeometry();
+                if (selectedFeature.properties.id === geometry.ol_uid) {
+                    this.activeDrawingLayerSource.removeFeature(drawingLayerFeature);
+                }
+            });
+        });
+        this.updateHeightTable();
+        this.activeStore.setLayerExtent();
+    }
+    /**
+     * Called when the user toggles the labels toggle
+     */
+    onToggleLabels() {
+        this.drawStyleService.toggleLabelsAreShown();
+        this.labelsAreShown = !this.labelsAreShown;
+        this.icon
+            ? this.elementStyle(this.labelsAreShown, true)
+            : this.elementStyle(this.labelsAreShown, false);
+        this.createDrawControl();
+    }
+    /**
+     * Called when the user toggles the Draw control is toggled
+     * @internal
+     */
+    onToggleDrawControl(toggleIsChecked) {
+        toggleIsChecked ? this.toggleDrawControl() : this.deactivateDrawControl();
+    }
+    onToggleFreehandMode(event) {
+        if (this.isCircle() && !event.checked) {
+            this.activeDrawControl.ispredefinedRadius$.next(true);
+            this.changeRadius(this.radiusFormControl.value);
+        }
+        else {
+            this.activeDrawControl.setOlInteractionStyle(createInteractionStyle(this.fillColor, this.strokeColor, this.strokeWidth));
+            this.activeDrawControl.ispredefinedRadius$.next(false);
+        }
+        this.freehandMode = event.checked;
+        this.activeDrawControl.freehand$.next(event.checked);
+        this.toggleDrawControl();
+    }
+    // User changes properties of a drawing element
+    /**
+     * Display the current layer with the current store and the current layerSource
+     */
+    onLayerChange(currLayer) {
+        if (currLayer) {
+            this.activeStore.state.updateAll({ selected: false });
+            this.isCreatingNewLayer = false;
+            this.activeDrawingLayer.opacity = 0;
+            this.activeDrawingLayer = currLayer;
+            this.activeDrawingLayer.opacity = 1;
+            this.deactivateDrawControl();
+            if (!this.labelsAreShown) {
+                this.onToggleLabels();
+            }
+            this.activeStore = this.stores.find((store) => store.layer.id === this.activeDrawingLayer.id);
+            this.activeDrawControl = this.drawControls.find((dc) => dc[0] === this.activeDrawingLayer.id)[1];
+            this.activeDrawingLayerSource =
+                this.activeDrawControl.olDrawingLayerSource;
+            this.activeDrawControl.setGeometryType(this.currGeometryType);
+            this.toggleDrawControl();
+        }
+        else {
+            this.setupLayer(true);
+        }
+        this.activeLayerChange.emit(this.activeDrawingLayer);
+    }
+    createLayer(newTitle, isNewLayer) {
+        for (const layer of this.allLayers) {
+            let numberId = Number(layer.id.replace('igo-draw-layer', ''));
+            this.layerCounterID = Math.max(numberId, this.layerCounterID);
+        }
+        this.activeDrawingLayer = new VectorLayer({
+            isIgoInternalLayer: true,
+            id: 'igo-draw-layer' + ++this.layerCounterID,
+            title: isNewLayer
+                ? newTitle
+                : this.languageService.translate.instant('igo.geo.draw.drawing'),
+            zIndex: 200,
+            source: new FeatureDataSource(),
+            style: (feature, resolution) => {
+                return this.drawStyleService.createIndividualElementStyle(feature, resolution, this.labelsAreShown, feature.get('fontStyle'), feature.get('drawingStyle').fill, feature.get('drawingStyle').stroke, feature.get('offsetX'), feature.get('offsetY'), this.map.projection, this.icon);
+            },
+            showInLayerList: true,
+            exportable: true,
+            browsable: false,
+            workspace: {
+                enabled: false
+            }
+        });
+        tryBindStoreLayer(this.activeStore, this.activeDrawingLayer);
+        tryAddLoadingStrategy(this.activeStore, new FeatureStoreLoadingStrategy({
+            motion: FeatureMotion.None
+        }));
+        tryAddSelectionStrategy(this.activeStore, new FeatureStoreSelectionStrategy({
+            map: this.map,
+            motion: FeatureMotion.None,
+            many: true
+        }));
+        this.activeStore.layer.visible = true;
+        this.activeStore.source.ol.on('removefeature', (event) => {
+            const olGeometry = event.feature.getGeometry();
+            this.clearLabelsOfOlGeometry(olGeometry);
+        });
+    }
+    /**
+     * Called when the user changes the color in a color picker
+     * @param labelsAreShown wheter the labels are shown or not
+     * @param isAnIcon wheter the feature is an icon or not
+     * @param fillColor which is the filling color
+     * @param strokeColor which is the stroke color
+     */
+    onColorChange(labelsAreShown, isAnIcon, fillColor, strokeColor) {
+        if (this.selectedFeatures$.value.length > 0 && !isAnIcon) {
+            this.selectedFeatures$.value.forEach((feature) => {
+                let olFeature = featureToOl(feature, this.map.ol.getView().getProjection().getCode());
+                this.updateFillAndStrokeColor(olFeature, fillColor, strokeColor);
+                const entity = this.activeStore
+                    .all()
+                    .find((e) => e.meta.id === olFeature.getId());
+                entity.properties.drawingStyle.fill = olFeature.get('fillColor_');
+                entity.properties.drawingStyle.stroke = olFeature.get('strokeColor_');
+                this.activeStore.update(entity);
+            });
+        }
+        this.elementStyle(labelsAreShown, isAnIcon);
+        this.createDrawControl();
+    }
+    /**
+     * Called when the user changes the font size or/and style
+     * @param labelsAreShown wheter the labels are shown or not
+     * @param size the size of the font
+     * @param style the style of the font
+     */
+    onFontChange(labelsAreShown, size, style) {
+        if (this.selectedFeatures$.value.length > 0) {
+            this.selectedFeatures$.value.forEach((feature) => {
+                let olFeature = featureToOl(feature, this.map.ol.getView().getProjection().getCode());
+                this.updateFontSizeAndStyle(olFeature, size, style);
+                const entity = this.activeStore
+                    .all()
+                    .find((e) => e.meta.id === olFeature.getId());
+                entity.properties.fontStyle = olFeature.get('fontStyle_');
+                this.activeStore.update(entity);
+                olFeature = this.activeStore.layer.ol
+                    .getSource()
+                    .getFeatures()
+                    .find((f) => f.getId() === entity.meta.id);
+                olFeature.setProperties({ fontStyle: entity.properties.fontStyle });
+                olFeature.changed();
+            });
+            this.fontSize = size;
+            this.fontStyle = style;
+            this.drawStyleService.setFontSize(size);
+            this.drawStyleService.setFontStyle(style);
+            this.elementStyle(labelsAreShown);
+        }
+    }
+    /**
+     * Called when the user changes the value of the horizontal/vertical offset
+     * @param labelsAreShown wheter the labels are shown or not
+     * @param offsetX horizontal offset of the label
+     * @param offsetY vertical offset of the label
+     */
+    onOffsetLabelChange(labelsAreShown, offsetX, offsetY) {
+        if (this.selectedFeatures$.value.length > 0) {
+            this.selectedFeatures$.value.forEach((feature) => {
+                let olFeature = featureToOl(feature, this.map.ol.getView().getProjection().getCode());
+                this.updateOffset(olFeature, offsetX, offsetY);
+                const entity = this.activeStore
+                    .all()
+                    .find((e) => e.meta.id === olFeature.getId());
+                entity.properties.offsetX = olFeature.get('offsetX_');
+                entity.properties.offsetY = olFeature.get('offsetY_');
+                this.activeStore.update(entity);
+                olFeature = this.activeStore.layer.ol
+                    .getSource()
+                    .getFeatures()
+                    .find((f) => f.getId() === entity.meta.id);
+                olFeature.setProperties({
+                    offsetX: entity.properties.offsetX,
+                    offsetY: entity.properties.offsetY
+                });
+                olFeature.changed();
+            });
+            this.elementStyle(labelsAreShown);
+        }
+    }
+    onIconChange(event) {
+        this.icon = event;
+        this.drawStyleService.setIcon(this.icon);
+        this.elementStyle(true, this.icon);
+    }
+    /**
+     * Called when the user selects a new geometry type
+     * @param geometryType the geometry type selected by the user
+     */
+    onGeometryTypeChange(geometryType) {
+        this.currGeometryType = geometryType;
+        this.activeDrawControl.setGeometryType(geometryType);
+        this.freehandMode
+            ? this.onToggleFreehandMode({ checked: true })
+            : this.onToggleFreehandMode({ checked: false });
+        this.toggleDrawControl();
+    }
+    // Updates the properties of olFeature inputted
+    /**
+     * Update the label of a geometry when a label is entered in a dialog box
+     * @param OlFeature the feature
+     * @param label the label
+     */
+    updateLabelOfOlGeometry(OlFeature, label) {
+        OlFeature.setProperties({
+            _label: label
+        }, true);
+    }
+    updateFontSizeAndStyle(olFeature, fontSize, fontStyle) {
+        olFeature.setProperties({
+            fontStyle_: `${fontSize}px ${fontStyle}`
+        }, true);
+    }
+    updateFillAndStrokeColor(olFeature, fillColor, strokeColor) {
+        olFeature.setProperties({
+            fillColor_: fillColor,
+            strokeColor_: strokeColor
+        }, true);
+    }
+    updateOffset(olFeature, offsetX, offsetY) {
+        olFeature.setProperties({
+            offsetX_: offsetX,
+            offsetY_: offsetY
+        }, true);
+    }
+    updateLabelType(olFeature, typeOfLabel) {
+        olFeature.setProperties({
+            labelType_: typeOfLabel
+        }, true);
+    }
+    updateMeasureUnit(olFeature, measureUnit) {
+        olFeature.setProperties({
+            measureUnit_: measureUnit
+        }, true);
+    }
+    // Updates values of the selected element on the HTML view
+    getFeatureFontSize() {
+        return this.selectedFeatures$.value.length > 0
+            ? this.selectedFeatures$.value[0].properties.fontStyle
+                .split(' ')[0]
+                .replace('px', '')
+            : '15';
+    }
+    getFeatureFontStyle() {
+        return this.selectedFeatures$.value.length > 0
+            ? this.selectedFeatures$.value[0].properties.fontStyle.substring(this.selectedFeatures$.value[0].properties.fontStyle.indexOf(' ') + 1)
+            : FontType.Arial;
+    }
+    getFeatureFillColor() {
+        return this.selectedFeatures$.value.length > 0
+            ? this.selectedFeatures$.value[0].properties.drawingStyle.fill
+            : 'rgba(255,255,255,0.4)';
+    }
+    getFeatureStrokeColor() {
+        return this.selectedFeatures$.value.length > 0
+            ? this.selectedFeatures$.value[0].properties.drawingStyle.stroke
+            : 'rgba(143,7,7,1)';
+    }
+    getFeatureOffsetX() {
+        return this.selectedFeatures$.value.length > 0
+            ? this.selectedFeatures$.value[0].properties.offsetX
+            : this.drawStyleService.getOffsetX();
+    }
+    getFeatureOffsetY() {
+        return this.selectedFeatures$.value.length > 0
+            ? this.selectedFeatures$.value[0].properties.offsetY
+            : '0';
+    }
+    get allFontStyles() {
+        return Object.values(FontType);
+    }
+    get allLayers() {
+        return this.map.layers.filter((layer) => String(layer.id).includes('igo-draw-layer'));
+    }
+    updateHeightTable() {
+        // Check the amount of rows as a possible alternative
+        this.numberOfDrawings = this.activeStore.count$.getValue();
+        this.numberOfDrawings > 10
+            ? (this.tableTemplate.tableHeight = '35vh')
+            : (this.tableTemplate.tableHeight = 'auto');
+    }
+    updateActiveLayer() {
+        let currLayer = this.allLayers.find((layer) => layer.title === this.activeDrawingLayer.title);
+        return currLayer ? currLayer : this.allLayers[0];
+    }
+    // Helper methods
+    /**
+     * Activate the correct control
+     */
+    toggleDrawControl() {
+        this.deactivateDrawControl();
+        this.activateDrawControl();
+    }
+    /**
+     * Clear the tooltips of an OL geometry
+     * @param olGeometry OL geometry with tooltips
+     */
+    clearLabelsOfOlGeometry(olGeometry) {
+        getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip) => {
+            if (olTooltip && olTooltip.getMap()) {
+                this.map.ol.removeOverlay(olTooltip);
+            }
+        });
+    }
+    /**
+     * Replace the feature in the store
+     * @param entity the entity to replace
+     * @param olGeometry the new geometry to insert in the store
+     */
+    replaceFeatureInStore(entity, olGeometry, radius) {
+        this.activeStore.delete(entity);
+        this.onDrawEnd(olGeometry, radius);
+    }
+    /**
+     * Deactivate the active draw control
+     */
+    deactivateDrawControl() {
+        if (!this.activeDrawControl) {
+            return;
+        }
+        if (this.drawEnd$$) {
+            this.drawEnd$$.unsubscribe();
+        }
+        this.activeDrawControl.setOlMap(undefined);
+        this.drawControlIsActive = false;
+    }
+    /**
+     * Activate a given control
+     */
+    activateDrawControl() {
+        this.drawControlIsDisabled = false;
+        this.drawControlIsActive = true;
+        this.drawEnd$$ = this.activeDrawControl.end$.subscribe((olGeometry) => {
+            this.openDrawDialog(olGeometry, true);
+        });
+        this.activeDrawControl.modify$.subscribe((olGeometry) => {
+            this.onModifyDraw(olGeometry);
+        });
+        if (!this.drawSelect$$) {
+            this.drawSelect$$ = this.activeDrawControl.select$.subscribe((olFeature) => {
+                this.openDrawDialog(olFeature, false);
+            });
+        }
+        this.activeDrawControl.setOlMap(this.map.ol, true);
+    }
+    /**
+     * get the geometry of design
+     *
+     */
+    isPoint() {
+        return this.activeDrawControl.getGeometryType() === this.geometryType.Point;
+    }
+    isLineString() {
+        return (this.activeDrawControl.getGeometryType() === this.geometryType.LineString);
+    }
+    isPolygon() {
+        return (this.activeDrawControl.getGeometryType() === this.geometryType.Polygon);
+    }
+    isCircle() {
+        return (this.activeDrawControl.getGeometryType() === this.geometryType.Circle);
+    }
+    /**
+     * The fonction to predefine the radius of the user
+     *
+     */
+    changeRadius(radius) {
+        let radiusMeters;
+        if (radius) {
+            this.measureUnit === MeasureLengthUnit.Meters
+                ? (radiusMeters = radius)
+                : (radiusMeters = radius * 1000);
+        }
+        else {
+            radiusMeters = undefined;
+        }
+        const pointStyle = (feature, resolution) => {
+            const geom = feature.getGeometry();
+            const coordinates = olproj.transform(geom.getCoordinates(), this.map.projection, 'EPSG:4326');
+            const radius = radiusMeters / Math.cos((Math.PI / 180) * coordinates[1]) / resolution;
+            this.activeDrawControl.predefinedRadius$.next(radiusMeters);
+            return new OlStyle.Style({
+                image: new OlStyle.Circle({
+                    radius: radius,
+                    stroke: new OlStyle.Stroke({
+                        width: 1,
+                        color: 'rgba(143,7,7,1)'
+                    }),
+                    fill: new OlStyle.Fill({
+                        color: 'rgba(255,255,255,0.4)'
+                    })
+                })
+            });
+        };
+        this.activeDrawControl.setOlInteractionStyle(pointStyle);
+        this.toggleDrawControl();
+    }
+    onMeasureUnitChange(selectedMeasureUnit) {
+        if (selectedMeasureUnit === this.measureUnit) {
+            return;
+        }
+        else {
+            this.measureUnit = selectedMeasureUnit;
+            this.measureUnit === MeasureLengthUnit.Meters
+                ? this.radiusFormControl.setValue(this.radiusFormControl.value * 1000)
+                : this.radiusFormControl.setValue(this.radiusFormControl.value / 1000);
+        }
+    }
+    /**
+     * Recreates the style of the feature stored
+     */
+    elementStyle(labelsAreShown, isAnIcon) {
+        if (isAnIcon) {
+            this.activeStore.layer.ol.setStyle((feature, resolution) => {
+                return this.drawStyleService.createIndividualElementStyle(feature, resolution, labelsAreShown, feature.get('fontStyle'), feature.get('drawingStyle').fill, feature.get('drawingStyle').stroke, feature.get('offsetX'), feature.get('offsetY'), this.map.projection, this.icon);
+            });
+        }
+        else {
+            this.activeStore.layer.ol.setStyle((feature, resolution) => {
+                return this.drawStyleService.createIndividualElementStyle(feature, resolution, labelsAreShown, feature.get('fontStyle'), feature.get('drawingStyle').fill, feature.get('drawingStyle').stroke, feature.get('offsetX'), feature.get('offsetY'), this.map.projection);
+            });
+        }
+    }
+    getRadius(olGeometry) {
+        const length = getLength(olGeometry);
+        return Number(length / (2 * Math.PI));
+    }
+    static ɵfac = function DrawComponent_Factory(t) { return new (t || DrawComponent)(i0.ɵɵdirectiveInject(i1.LanguageService), i0.ɵɵdirectiveInject(i2.UntypedFormBuilder), i0.ɵɵdirectiveInject(i3.DrawStyleService), i0.ɵɵdirectiveInject(i4.MatDialog), i0.ɵɵdirectiveInject(i5.DrawIconService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DrawComponent, selectors: [["igo-draw"]], viewQuery: function DrawComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.select = _t.first);
+        } }, inputs: { map: "map", stores: "stores", drawControls: "drawControls", activeDrawingLayer: "activeDrawingLayer" }, outputs: { activeLayerChange: "activeLayerChange", drawControlsEvent: "drawControlsEvent", layersIDEvent: "layersIDEvent", fillColor: "fillColor", strokeColor: "strokeColor", strokeWidth: "strokeWidth", fontSize: "fontSize", fontStyle: "fontStyle" }, decls: 50, vars: 47, consts: [[1, "geometry-type-toggle", "mat-typography"], [3, "value", "change"], [3, "value"], [1, "draw-options", "mat-typography"], [3, "disabled", "checked", "labelPosition", "change"], [3, "checked", "labelPosition", "change"], [3, "checked", "labelPosition", "change", 4, "ngIf"], ["class", "radius-unit", 4, "ngIf"], [1, "layer-select-container"], ["subscriptSizing", "dynamic", 1, "layer-select"], [3, "value", "selectionChange"], ["selectedLayer", ""], [3, "value", 4, "ngFor", "ngForOf"], ["id", "createNewLayer"], ["mat-icon-button", "", "collapsibleButton", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "color", "matTooltip", "click", 4, "ngIf"], ["class", "deleteBtn", "mat-icon-button", "", "color", "warn", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "matTooltip", "disabled", "click", 4, "ngIf"], [1, "table-compact", 3, "store", "template"], ["table", ""], [1, "icon-options"], [4, "ngIf"], [1, "actions-container"], ["mat-icon-button", "", "color", "accent", "disableRipple", "true", 3, "click"], ["svgIcon", "keyboard-outline", "tooltip-position", "below", "matTooltipShowDelay", "500", 1, "shortcuts-icon", 3, "matTooltip"], ["mat-raised-button", "", "color", "primary", 3, "matTooltip", "click", 4, "ngIf"], [1, "radius-unit"], [1, "radius-form"], [1, "radius"], ["matInput", "", "type", "number", "min", "0", 3, "placeholder", "formControl", "readonly"], [1, "unit-field"], ["mat-icon-button", "", "collapsibleButton", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "color", "matTooltip", "click"], [3, "svgIcon"], ["mat-icon-button", "", "color", "warn", "tooltip-position", "below", "matTooltipShowDelay", "500", 1, "deleteBtn", 3, "matTooltip", "disabled", "click"], ["svgIcon", "delete"], ["class", "box", 4, "ngIf"], ["value", "", 3, "click"], [3, "value", "click", 4, "ngFor", "ngForOf"], [1, "box"], [3, "src"], [3, "value", "click"], ["mat-raised-button", "", "color", "primary", 3, "matTooltip", "click"], ["aria-hidden", "false", "iconPositionEnd", "", "svgIcon", "palette", "matBadgeColor", "warn", "matBadgeSize", "medium", 1, "style-icon", 3, "matBadge"]], template: function DrawComponent_Template(rf, ctx) { if (rf & 1) {
+            const _r29 = i0.ɵɵgetCurrentView();
+            i0.ɵɵelementStart(0, "div")(1, "div", 0)(2, "mat-button-toggle-group", 1);
+            i0.ɵɵlistener("change", function DrawComponent_Template_mat_button_toggle_group_change_2_listener($event) { return ctx.onGeometryTypeChange($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, "mat-button-toggle", 2);
+            i0.ɵɵtext(10);
+            i0.ɵɵpipe(11, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(12, "mat-button-toggle", 2);
+            i0.ɵɵtext(13);
+            i0.ɵɵpipe(14, "translate");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(15, "div", 3)(16, "mat-slide-toggle", 4);
+            i0.ɵɵlistener("change", function DrawComponent_Template_mat_slide_toggle_change_16_listener($event) { return ctx.onToggleDrawControl($event.checked); });
+            i0.ɵɵtext(17);
+            i0.ɵɵpipe(18, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(19, "mat-slide-toggle", 5);
+            i0.ɵɵlistener("change", function DrawComponent_Template_mat_slide_toggle_change_19_listener() { return ctx.onToggleLabels(); });
+            i0.ɵɵtext(20);
+            i0.ɵɵpipe(21, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵtemplate(22, DrawComponent_mat_slide_toggle_22_Template, 3, 5, "mat-slide-toggle", 6);
+            i0.ɵɵtemplate(23, DrawComponent_div_23_Template, 8, 7, "div", 7);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelement(24, "mat-divider");
+            i0.ɵɵelementStart(25, "div", 8)(26, "mat-form-field", 9)(27, "mat-label");
+            i0.ɵɵtext(28);
+            i0.ɵɵpipe(29, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(30, "mat-select", 10, 11);
+            i0.ɵɵlistener("selectionChange", function DrawComponent_Template_mat_select_selectionChange_30_listener() { i0.ɵɵrestoreView(_r29); const _r2 = i0.ɵɵreference(31); return i0.ɵɵresetView(ctx.onLayerChange(_r2.value)); });
+            i0.ɵɵtemplate(32, DrawComponent_mat_option_32_Template, 2, 2, "mat-option", 12);
+            i0.ɵɵelementStart(33, "mat-option", 13);
+            i0.ɵɵtext(34);
+            i0.ɵɵpipe(35, "translate");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵtemplate(36, DrawComponent_button_36_Template, 4, 7, "button", 14);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelement(37, "mat-divider");
+            i0.ɵɵelementStart(38, "div");
+            i0.ɵɵtemplate(39, DrawComponent_button_39_Template, 4, 6, "button", 15);
+            i0.ɵɵelementStart(40, "div");
+            i0.ɵɵelement(41, "igo-entity-table", 16, 17);
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelementStart(43, "div", 18);
+            i0.ɵɵtemplate(44, DrawComponent_mat_form_field_44_Template, 11, 8, "mat-form-field", 19);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(45, "div", 20)(46, "button", 21);
+            i0.ɵɵlistener("click", function DrawComponent_Template_button_click_46_listener() { return ctx.openShorcutsDialog(); });
+            i0.ɵɵelement(47, "mat-icon", 22);
+            i0.ɵɵpipe(48, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵtemplate(49, DrawComponent_button_49_Template, 5, 7, "button", 23);
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.geometryType.Point);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("value", ctx.geometryType.Point);
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 29, "igo.geo.draw." + ctx.geometryType.Point), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.geometryType.LineString);
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(8, 31, "igo.geo.draw." + ctx.geometryType.LineString), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.geometryType.Polygon);
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(11, 33, "igo.geo.draw." + ctx.geometryType.Polygon), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.geometryType.Circle);
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(14, 35, "igo.geo.draw." + ctx.geometryType.Circle), " ");
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("disabled", ctx.drawControlIsDisabled)("checked", ctx.drawControlIsActive)("labelPosition", "before");
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(18, 37, "igo.geo.draw.drawControl"), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("checked", ctx.labelsAreShown)("labelPosition", "before");
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(21, 39, "igo.geo.draw.toggleMapTooltips"), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", !ctx.isPoint());
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngIf", ctx.isCircle());
+            i0.ɵɵadvance(5);
+            i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(29, 41, "igo.geo.draw.layer.title"));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.updateActiveLayer());
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngForOf", ctx.allLayers);
+            i0.ɵɵadvance(2);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(35, 43, "igo.geo.draw.layer.createNewLayer"), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", ctx.activeDrawingLayer);
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", ctx.activeStore.count$.getValue() > 0);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("store", ctx.activeStore)("template", ctx.tableTemplate);
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", ctx.icons.length >= 1);
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(48, 45, "igo.geo.draw.shortcuts"));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", ctx.selectedFeatures$.value.length);
+        } }, dependencies: [i2.ɵNgNoValidate, i2.DefaultValueAccessor, i2.NumberValueAccessor, i2.NgControlStatus, i2.NgControlStatusGroup, i2.MinValidator, i2.NgForm, i2.FormControlDirective, i6.NgForOf, i6.NgIf, i7.MatButton, i7.MatIconButton, i8.MatButtonToggleGroup, i8.MatButtonToggle, i9.MatDivider, i10.MatFormField, i10.MatLabel, i11.MatIcon, i12.MatBadge, i13.MatTooltip, i14.MatInput, i15.MatSelect, i15.MatSelectTrigger, i16.MatOption, i17.MatSlideToggle, i18.EntityTableComponent, i6.AsyncPipe, i19.TranslatePipe], styles: ["[_nghost-%COMP%]   .geometry-type-toggle[_ngcontent-%COMP%]{padding:10px;text-align:center}[_nghost-%COMP%]   .geometry-type-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]{width:100%}[_nghost-%COMP%]   .geometry-type-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]   mat-button-toggle[_ngcontent-%COMP%]{width:25%}[_nghost-%COMP%]   .draw-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]{width:100%;padding:10px}[_nghost-%COMP%]   .draw-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-form-field{width:100%}[_nghost-%COMP%]   .draw-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-label{margin-left:0;width:calc(100% - 60px)}[_nghost-%COMP%]   .icon-options[_ngcontent-%COMP%]{margin:5px 5px 0}[_nghost-%COMP%]   .deleteBtn[_ngcontent-%COMP%]{margin-left:16px}[_nghost-%COMP%]   .edition-drawing[_ngcontent-%COMP%]{padding:10px 0}[_nghost-%COMP%]   img[_ngcontent-%COMP%]{width:100%;height:100%}[_nghost-%COMP%]   .deleteBtn[_ngcontent-%COMP%]{margin-left:12px}[_nghost-%COMP%]   .storeTable[_ngcontent-%COMP%]{height:auto!important}[_nghost-%COMP%]   .layer-select[_ngcontent-%COMP%]{flex:1;margin-right:8px}[_nghost-%COMP%]   .input-button-container[_ngcontent-%COMP%]{padding:10px}[_nghost-%COMP%]   .input-button-container[_ngcontent-%COMP%]   mat-form-field[_ngcontent-%COMP%]{width:25%}[_nghost-%COMP%]   .input-button-container[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{left:8px;bottom:10px}[_nghost-%COMP%]   .radius[_ngcontent-%COMP%]{display:flex;flex-flow:column nowrap;width:110%}[_nghost-%COMP%]   .unit-field[_ngcontent-%COMP%]{width:110px;margin-left:30px}[_nghost-%COMP%]   .radius-unit[_ngcontent-%COMP%]{display:flex;width:100%;padding:4px 8px}[_nghost-%COMP%]     igo-entity-table td:last-child{text-align:right!important}[_nghost-%COMP%]     igo-entity-table td:last-child button{margin:0%!important}[_nghost-%COMP%]   .layer-select-container[_ngcontent-%COMP%]{margin:16px 8px}[_nghost-%COMP%]   .actions-container[_ngcontent-%COMP%], [_nghost-%COMP%]   .layer-select-container[_ngcontent-%COMP%]{display:flex;align-items:center}"], data: { animation: [
+                trigger('openClose', [
+                    state('open', style({
+                        opacity: 1
+                    })),
+                    state('closed', style({
+                        opacity: 0
+                    })),
+                    transition('open => closed', [animate('600ms ease')]),
+                    transition('closed => open', [animate('800ms ease')])
+                ])
+            ] }, changeDetection: 0 });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrawComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-draw', animations: [
+                    trigger('openClose', [
+                        state('open', style({
+                            opacity: 1
+                        })),
+                        state('closed', style({
+                            opacity: 0
+                        })),
+                        transition('open => closed', [animate('600ms ease')]),
+                        transition('closed => open', [animate('800ms ease')])
+                    ])
+                ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div>\n  <div class=\"geometry-type-toggle mat-typography\">\n    <mat-button-toggle-group\n      (change)=\"onGeometryTypeChange($event.value)\"\n      [value]=\"geometryType.Point\"\n    >\n      <mat-button-toggle [value]=\"geometryType.Point\">\n        {{ 'igo.geo.draw.' + geometryType.Point | translate }}\n      </mat-button-toggle>\n\n      <mat-button-toggle [value]=\"geometryType.LineString\">\n        {{ 'igo.geo.draw.' + geometryType.LineString | translate }}\n      </mat-button-toggle>\n\n      <mat-button-toggle [value]=\"geometryType.Polygon\">\n        {{ 'igo.geo.draw.' + geometryType.Polygon | translate }}\n      </mat-button-toggle>\n\n      <mat-button-toggle [value]=\"geometryType.Circle\">\n        {{ 'igo.geo.draw.' + geometryType.Circle | translate }}\n      </mat-button-toggle>\n    </mat-button-toggle-group>\n  </div>\n\n  <div class=\"draw-options mat-typography\">\n    <mat-slide-toggle\n      [disabled]=\"drawControlIsDisabled\"\n      [checked]=\"drawControlIsActive\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDrawControl($event.checked)\"\n    >\n      {{ 'igo.geo.draw.drawControl' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      [checked]=\"labelsAreShown\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleLabels()\"\n    >\n      {{ 'igo.geo.draw.toggleMapTooltips' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      *ngIf=\"!isPoint()\"\n      [checked]=\"freehandMode\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleFreehandMode($event)\"\n    >\n      {{ 'igo.geo.draw.freehandMode' | translate }}\n    </mat-slide-toggle>\n\n    <div class=\"radius-unit\" *ngIf=\"isCircle()\">\n      <form class=\"radius-form\">\n        <mat-form-field class=\"radius\">\n          <input\n            matInput\n            type=\"number\"\n            min=\"0\"\n            placeholder=\"{{ 'igo.geo.spatialFilter.radius' | translate }}\"\n            [formControl]=\"radiusFormControl\"\n            [readonly]=\"this.freehandMode\"\n          />\n        </mat-form-field>\n      </form>\n\n      <mat-form-field class=\"unit-field\">\n        <mat-select\n          [value]=\"measureUnit\"\n          (selectionChange)=\"onMeasureUnitChange($event.value)\"\n        >\n          <mat-option\n            *ngFor=\"let measureUnit of measureUnits\"\n            [value]=\"measureUnit\"\n          >\n            {{ 'igo.geo.measure.' + measureUnit | translate }}\n          </mat-option>\n        </mat-select>\n      </mat-form-field>\n    </div>\n  </div>\n\n  <mat-divider></mat-divider>\n\n  <div class=\"layer-select-container\">\n    <mat-form-field class=\"layer-select\" subscriptSizing=\"dynamic\">\n      <mat-label>{{ 'igo.geo.draw.layer.title' | translate }}</mat-label>\n      <mat-select\n        #selectedLayer\n        (selectionChange)=\"onLayerChange(selectedLayer.value)\"\n        [value]=\"updateActiveLayer()\"\n      >\n        <mat-option *ngFor=\"let layer of allLayers\" [value]=\"layer\">\n          {{ layer.title }}\n        </mat-option>\n        <mat-option id=\"createNewLayer\">\n          {{ 'igo.geo.draw.layer.createNewLayer' | translate }}\n        </mat-option>\n      </mat-select>\n    </mat-form-field>\n    <button\n      *ngIf=\"activeDrawingLayer\"\n      mat-icon-button\n      [color]=\"activeDrawingLayer.visible ? 'primary' : 'default'\"\n      collapsibleButton\n      tooltip-position=\"below\"\n      matTooltipShowDelay=\"500\"\n      [matTooltip]=\"\n        activeDrawingLayer.visible\n          ? ('igo.geo.layer.hideLayer' | translate)\n          : ('igo.geo.layer.showLayer' | translate)\n      \"\n      (click)=\"activeDrawingLayer.visible = !activeDrawingLayer.visible\"\n    >\n      <mat-icon [svgIcon]=\"activeDrawingLayer.visible ? 'eye' : 'eye-off'\">\n      </mat-icon>\n    </button>\n  </div>\n  <mat-divider></mat-divider>\n  <div>\n    <button\n      *ngIf=\"activeStore.count$.getValue() > 0\"\n      class=\"deleteBtn\"\n      mat-icon-button\n      color=\"warn\"\n      tooltip-position=\"below\"\n      matTooltipShowDelay=\"500\"\n      [matTooltip]=\"'igo.geo.draw.delete' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      (click)=\"deleteDrawings()\"\n    >\n      <mat-icon svgIcon=\"delete\"></mat-icon>\n    </button>\n\n    <div>\n      <igo-entity-table\n        #table\n        class=\"table-compact\"\n        [store]=\"activeStore\"\n        [template]=\"tableTemplate\"\n      >\n      </igo-entity-table>\n    </div>\n  </div>\n\n  <div class=\"icon-options\">\n    <mat-form-field *ngIf=\"icons.length >= 1\">\n      <mat-label>{{ 'igo.geo.draw.icon' | translate }}</mat-label>\n      <mat-select>\n        <mat-select-trigger>\n          <div *ngIf=\"icon\" class=\"box\">\n            <img src=\"{{ icon }}\" />\n          </div>\n        </mat-select-trigger>\n        <mat-option value=\"\" (click)=\"onIconChange()\">{{\n          'igo.geo.draw.noIcon' | translate\n        }}</mat-option>\n        <mat-option\n          *ngFor=\"let icon_html of icons\"\n          [value]=\"icon_html\"\n          (click)=\"onIconChange(icon_html)\"\n        >\n          <div class=\"box\">\n            <img src=\"{{ icon_html }}\" />\n          </div>\n        </mat-option>\n      </mat-select>\n    </mat-form-field>\n  </div>\n\n  <div class=\"actions-container\">\n    <button\n      mat-icon-button\n      color=\"accent\"\n      disableRipple=\"true\"\n      (click)=\"openShorcutsDialog()\"\n    >\n      <mat-icon\n        class=\"shortcuts-icon\"\n        svgIcon=\"keyboard-outline\"\n        tooltip-position=\"below\"\n        matTooltipShowDelay=\"500\"\n        [matTooltip]=\"'igo.geo.draw.shortcuts' | translate\"\n      >\n      </mat-icon>\n    </button>\n\n    <button\n      *ngIf=\"selectedFeatures$.value.length\"\n      mat-raised-button\n      color=\"primary\"\n      (click)=\"openStyleModalDialog()\"\n      [matTooltip]=\"'igo.geo.style.styleModalTooltipSelected' | translate\"\n    >\n      {{ 'igo.geo.style.styleModal' | translate }}\n      <mat-icon\n        aria-hidden=\"false\"\n        iconPositionEnd\n        class=\"style-icon\"\n        svgIcon=\"palette\"\n        [matBadge]=\"selectedFeatures$.value.length\"\n        matBadgeColor=\"warn\"\n        matBadgeSize=\"medium\"\n      >\n      </mat-icon>\n    </button>\n  </div>\n</div>\n", styles: [":host .geometry-type-toggle{padding:10px;text-align:center}:host .geometry-type-toggle mat-button-toggle-group{width:100%}:host .geometry-type-toggle mat-button-toggle-group mat-button-toggle{width:25%}:host .draw-options mat-slide-toggle{width:100%;padding:10px}:host .draw-options mat-slide-toggle ::ng-deep .mdc-form-field{width:100%}:host .draw-options mat-slide-toggle ::ng-deep .mdc-label{margin-left:0;width:calc(100% - 60px)}:host .icon-options{margin:5px 5px 0}:host .deleteBtn{margin-left:16px}:host .edition-drawing{padding:10px 0}:host img{width:100%;height:100%}:host .deleteBtn{margin-left:12px}:host .storeTable{height:auto!important}:host .layer-select{flex:1;margin-right:8px}:host .input-button-container{padding:10px}:host .input-button-container mat-form-field{width:25%}:host .input-button-container button{left:8px;bottom:10px}:host .radius{display:flex;flex-flow:column nowrap;width:110%}:host .unit-field{width:110px;margin-left:30px}:host .radius-unit{display:flex;width:100%;padding:4px 8px}:host ::ng-deep igo-entity-table td:last-child{text-align:right!important}:host ::ng-deep igo-entity-table td:last-child button{margin:0%!important}:host .layer-select-container{margin:16px 8px}:host .actions-container,:host .layer-select-container{display:flex;align-items:center}\n"] }]
+    }], function () { return [{ type: i1.LanguageService }, { type: i2.UntypedFormBuilder }, { type: i3.DrawStyleService }, { type: i4.MatDialog }, { type: i5.DrawIconService }]; }, { map: [{
+            type: Input
+        }], stores: [{
+            type: Input
+        }], drawControls: [{
+            type: Input
+        }], activeDrawingLayer: [{
+            type: Input
+        }], activeLayerChange: [{
+            type: Output
+        }], drawControlsEvent: [{
+            type: Output
+        }], layersIDEvent: [{
+            type: Output
+        }], fillColor: [{
+            type: Output
+        }], strokeColor: [{
+            type: Output
+        }], strokeWidth: [{
+            type: Output
+        }], fontSize: [{
+            type: Output
+        }], fontStyle: [{
+            type: Output
+        }], select: [{
+            type: ViewChild,
+            args: ['selectedLayer']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draw.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/draw/draw/draw.component.ts","../../../../../../packages/geo/src/lib/draw/draw/draw.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  OnInit,\n  OnDestroy,\n  ChangeDetectionStrategy,\n  Output,\n  EventEmitter,\n  ViewChild\n} from '@angular/core';\n\nimport {\n  FEATURE,\n  FeatureStore,\n  FeatureStoreSelectionStrategy,\n  tryAddLoadingStrategy,\n  tryAddSelectionStrategy,\n  FeatureMotion,\n  FeatureStoreLoadingStrategy,\n  featureToOl\n} from '../../feature';\n\nimport { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';\n\nimport { LanguageService } from '@igo2/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { CoordinatesUnit, GeometryType, LabelType } from '../shared/draw.enum';\nimport { FontType } from '../../style/shared/font.enum';\nimport { IgoMap } from '../../map/shared/map';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { Draw, FeatureWithDraw } from '../shared/draw.interface';\nimport {\n  UntypedFormGroup,\n  UntypedFormBuilder,\n  UntypedFormControl\n} from '@angular/forms';\nimport { VectorSourceEvent as OlVectorSourceEvent } from 'ol/source/Vector';\nimport { VectorLayer } from '../../layer/shared/layers/vector-layer';\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\nimport { DrawControl } from '../../geometry/shared/controls/draw';\nimport {\n  EntityRecord,\n  EntityTableButton,\n  EntityTableColumnRenderer,\n  EntityTableTemplate\n} from '@igo2/common';\n\nimport * as OlStyle from 'ol/style';\nimport * as olproj from 'ol/proj';\nimport OlVectorSource from 'ol/source/Vector';\nimport OlCircle from 'ol/geom/Circle';\nimport OlPoint from 'ol/geom/Point';\nimport OlFeature from 'ol/Feature';\nimport OlGeoJSON from 'ol/format/GeoJSON';\nimport OlOverlay from 'ol/Overlay';\nimport type { Type } from 'ol/geom/Geometry';\nimport { default as OlGeometry } from 'ol/geom/Geometry';\nimport { getDistance, getLength } from 'ol/sphere';\nimport { DrawStyleService } from '../../style/style-service/draw-style.service';\nimport { first, skip } from 'rxjs/operators';\nimport { DrawPopupComponent } from './draw-popup.component';\nimport { DrawShorcutsComponent } from './draw-shorcuts.component';\nimport { getTooltipsOfOlGeometry } from '../../measure/shared/measure.utils';\nimport { createInteractionStyle, DDtoDMS } from '../shared/draw.utils';\nimport { transform } from 'ol/proj';\nimport { DrawIconService } from '../shared/draw-icon.service';\nimport { StyleModalDrawingComponent } from '../../style/style-modal/drawing/style-modal-drawing.component';\nimport { StyleModalData } from '../../style/style-modal/shared/style-modal.interface';\n\nimport {\n  trigger,\n  state,\n  style,\n  animate,\n  transition\n} from '@angular/animations';\n\nimport { DrawLayerPopupComponent } from './draw-layer-popup.component';\n\nimport {\n  measureOlGeometryLength,\n  measureOlGeometryArea,\n  metersToUnit,\n  squareMetersToUnit\n} from '../../measure/shared/measure.utils';\n\nimport {\n  MeasureLengthUnit,\n  MeasureLengthUnitAbbreviation,\n  MeasureAreaUnit,\n  MeasureAreaUnitAbbreviation\n} from '../../measure/shared/measure.enum';\nimport Polygon, { fromCircle } from 'ol/geom/Polygon';\n\n@Component({\n  selector: 'igo-draw',\n  animations: [\n    trigger('openClose', [\n      state(\n        'open',\n        style({\n          opacity: 1\n        })\n      ),\n      state(\n        'closed',\n        style({\n          opacity: 0\n        })\n      ),\n      transition('open => closed', [animate('600ms ease')]),\n      transition('closed => open', [animate('800ms ease')])\n    ])\n  ],\n  templateUrl: './draw.component.html',\n  styleUrls: ['./draw.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class DrawComponent implements OnInit, OnDestroy {\n  /**\n   * Table template\n   * @internal\n   */\n  public tableTemplate: EntityTableTemplate;\n\n  public geometryType = GeometryType; // Reference to the GeometryType enum\n  @Input() map: IgoMap; // Map to draw on\n\n  @Input()\n  get stores(): FeatureStore<FeatureWithDraw>[] {\n    return this._stores;\n  }\n  set stores(value: FeatureStore<FeatureWithDraw>[]) {\n    this._stores = value;\n  }\n  private _stores: FeatureStore<FeatureWithDraw>[] = [];\n\n  @Input()\n  get drawControls(): [string, DrawControl][] {\n    return this._drawControls;\n  }\n  set drawControls(value: [string, DrawControl][]) {\n    this._drawControls = value;\n  }\n  private _drawControls = [];\n\n  @Input()\n  get activeDrawingLayer(): VectorLayer {\n    return this._activeDrawingLayer;\n  }\n  set activeDrawingLayer(value: VectorLayer) {\n    this._activeDrawingLayer = value;\n  }\n  private _activeDrawingLayer: VectorLayer;\n\n  @Output() activeLayerChange = new EventEmitter<VectorLayer>();\n  @Output() drawControlsEvent = new EventEmitter<[string, DrawControl][]>();\n  @Output() layersIDEvent = new EventEmitter<string>();\n\n  @Output() fillColor: string;\n  @Output() strokeColor: string;\n  @Output() strokeWidth: number;\n\n  @Output() fontSize: string;\n  @Output() fontStyle: string;\n\n  public activeStore: FeatureStore<FeatureWithDraw>;\n  private layerCounterID: number = 0;\n  public draw$: BehaviorSubject<Draw> = new BehaviorSubject({}); // Observable of draw\n  private activeDrawingLayerSource = new OlVectorSource();\n  private activeDrawControl: DrawControl;\n  private drawEnd$$: Subscription;\n  private drawSelect$$: Subscription;\n  public selectedFeatures$: BehaviorSubject<FeatureWithDraw[]> =\n    new BehaviorSubject([]);\n  public fillForm: string;\n  public strokeForm: string;\n  public drawControlIsDisabled: boolean = true;\n  public drawControlIsActive: boolean = false;\n  public labelsAreShown: boolean;\n  public freehandMode = false;\n  private subscriptions$$: Subscription[] = [];\n\n  public position: string = 'bottom';\n  public form: UntypedFormGroup;\n  public icons: Array<string>;\n  public icon: string;\n\n  public radiusFormControl = new UntypedFormControl(1000);\n  public measureUnit: MeasureLengthUnit = MeasureLengthUnit.Meters;\n  public radiusFormControlChange$$: Subscription = new Subscription();\n  public predefinedRadius$: BehaviorSubject<number> = new BehaviorSubject(\n    undefined\n  );\n  public radiusDrawEnd$: BehaviorSubject<number> = new BehaviorSubject(\n    undefined\n  );\n\n  /**\n   * Available measure units for the measure type given\n   * @internal\n   */\n  get measureUnits(): string[] {\n    return [MeasureLengthUnit.Meters, MeasureLengthUnit.Kilometers];\n  }\n  private numberOfDrawings: number;\n  public isCreatingNewLayer: boolean = false;\n  private currGeometryType = this.geometryType.Point as any;\n\n  @ViewChild('selectedLayer') select;\n\n  constructor(\n    private languageService: LanguageService,\n    private formBuilder: UntypedFormBuilder,\n    private drawStyleService: DrawStyleService,\n    private dialog: MatDialog,\n    private drawIconService: DrawIconService\n  ) {\n    this.tableTemplate = {\n      selection: true,\n      selectMany: true,\n      selectionCheckbox: true,\n      sort: true,\n      fixedHeader: true,\n      tableHeight: 'auto',\n      columns: [\n        {\n          name: 'Drawing',\n          title: this.languageService.translate.instant('igo.geo.draw.labels'),\n          valueAccessor: (feature: FeatureWithDraw) => {\n            return feature.properties.draw;\n          }\n        },\n        {\n          name: 'Edition',\n          title: '',\n          sort: false,\n          valueAccessor: (feature: FeatureWithDraw) => {\n            return [\n              {\n                editMode: false,\n                icon: 'pencil',\n                color: 'primary',\n                click: () => {\n                  this.editLabelDrawing(feature);\n                },\n                style: 'mat-icon-button'\n              }\n            ] as EntityTableButton[];\n          },\n          renderer: EntityTableColumnRenderer.ButtonGroup\n        }\n      ]\n    };\n    this.buildForm();\n    this.fillColor = this.drawStyleService.getFillColor();\n    this.strokeColor = this.drawStyleService.getStrokeColor();\n    this.strokeWidth = this.drawStyleService.getStrokeWidth();\n    this.labelsAreShown = this.drawStyleService.getLabelsAreShown();\n    this.icons = this.drawIconService.getIcons();\n    this.icon = this.drawStyleService.getIcon();\n\n    this.fontSize = this.drawStyleService.getFontSize();\n    this.fontStyle = this.drawStyleService.getFontStyle();\n  }\n\n  // Initialize the store that will contain the entities and create the Draw control\n  ngOnInit() {\n    if (!this.stores.length) {\n      this.activeStore = new FeatureStore<FeatureWithDraw>([], {\n        map: this.map\n      });\n      this.initStore();\n      this.activeDrawControl = this.createDrawControl(\n        this.fillColor,\n        this.strokeColor,\n        this.strokeWidth\n      );\n      this.activeDrawControl.setGeometryType(this.geometryType.Point as any);\n      this.toggleDrawControl();\n      this.stores.push(this.activeStore);\n      this.drawControls.push([\n        this.activeDrawingLayer.id,\n        this.activeDrawControl\n      ]);\n      this.drawControlsEvent.emit(this.drawControls);\n      this.layersIDEvent.emit(this.activeDrawingLayer.id);\n      this.onLayerChange(this.activeDrawingLayer);\n    } else {\n      this.activeStore = this.stores.find(\n        (store) => store.layer.id === this.activeDrawingLayer.id\n      );\n      this.activeDrawControl = this.drawControls.find(\n        (dc) => dc[0] === this.activeDrawingLayer.id\n      )[1];\n      this.deactivateDrawControl();\n      this.allLayers.forEach((layer) => {\n        if (layer.id !== this.activeDrawingLayer.id) {\n          layer.opacity = 0;\n        }\n        let store = this.stores.find((s) => s.layer.id === layer.id);\n\n        this.subscriptions$$.push(\n          store.stateView\n            .manyBy$((record: EntityRecord<FeatureWithDraw>) => {\n              return record.state.selected === true;\n            })\n            .pipe(first())\n            .subscribe((records: EntityRecord<FeatureWithDraw>[]) => {\n              records.forEach((record) => {\n                record.state.selected = false;\n              });\n            })\n        );\n\n        this.subscriptions$$.push(\n          store.stateView\n            .manyBy$((record: EntityRecord<FeatureWithDraw>) => {\n              return record.state.selected === true;\n            })\n            .pipe(\n              skip(1) // Skip initial emission\n            )\n            .subscribe((records: EntityRecord<FeatureWithDraw>[]) => {\n              this.selectedFeatures$.next(\n                records.map((record) => record.entity)\n              );\n            })\n        );\n\n        this.subscriptions$$.push(\n          store.count$.subscribe((cnt) => {\n            cnt >= 1\n              ? (this.activeStore.layer.options.showInLayerList = true)\n              : (this.activeStore.layer.options.showInLayerList = false);\n          })\n        );\n      });\n      this.onLayerChange(this.activeDrawingLayer);\n    }\n\n    this.radiusFormControlChange$$ =\n      this.radiusFormControl.valueChanges.subscribe((value) => {\n        if (this.activeDrawControl.ispredefinedRadius$.getValue()) {\n          this.changeRadius(value);\n        }\n      });\n  }\n\n  /**\n   * Remove the drawing layer and the interactions\n   * @internal\n   */\n  ngOnDestroy() {\n    this.allLayers.forEach((layer) => (layer.opacity = 1));\n    this.activeStore.state.updateAll({ selected: false });\n    this.deactivateDrawControl();\n    this.subscriptions$$.map((s) => s.unsubscribe());\n    this.radiusFormControlChange$$.unsubscribe();\n  }\n\n  /**\n   * Create a Draw Control\n   * @param fillColor the fill color\n   * @param strokeColor the stroke color\n   * @param strokeWidth the stroke width\n   * @returns a Draw Control\n   */\n  createDrawControl(\n    fillColor?: string,\n    strokeColor?: string,\n    strokeWidth?: number\n  ) {\n    const activeDrawControl = new DrawControl({\n      geometryType: undefined,\n      drawingLayerSource: this.activeDrawingLayerSource,\n      drawingLayerStyle: new OlStyle.Style({}),\n      interactionStyle: createInteractionStyle(\n        fillColor,\n        strokeColor,\n        strokeWidth\n      )\n    });\n    return activeDrawControl;\n  }\n\n  /**\n   * Store initialization, including drawing layer creation\n   */\n\n  private initStore(newTitle?: string, isNewLayer?: boolean) {\n    this.createLayer(newTitle, isNewLayer);\n    this.subscriptions$$.push(\n      this.activeStore.stateView\n        .manyBy$((record: EntityRecord<FeatureWithDraw>) => {\n          return record.state.selected === true;\n        })\n        .pipe(\n          skip(1) // Skip initial emission\n        )\n        .subscribe((records: EntityRecord<FeatureWithDraw>[]) => {\n          this.selectedFeatures$.next(records.map((record) => record.entity));\n        })\n    );\n\n    this.subscriptions$$.push(\n      this.activeStore.count$.subscribe((cnt) => {\n        cnt >= 1\n          ? (this.activeStore.layer.options.showInLayerList = true)\n          : (this.activeStore.layer.options.showInLayerList = false);\n      })\n    );\n  }\n\n  /**\n   * Open the style modal dialog box\n   */\n  openStyleModalDialog() {\n    setTimeout(() => {\n      // open the dialog box used to style features\n      const dialogRef = this.dialog.open(StyleModalDrawingComponent, {\n        disableClose: false,\n        data: {\n          features: this.selectedFeatures$.getValue(),\n          icons: this.icons,\n          icon: this.icon\n        },\n        autoFocus: false\n      });\n\n      // when dialog box is closed, get label and set it to geometry\n      dialogRef.afterClosed().subscribe((data: StyleModalData) => {\n        // checks if the user clicked ok\n        if (dialogRef.componentInstance.confirmFlag) {\n          this.onFontChange(this.labelsAreShown, data.fontSize, data.fontStyle);\n          this.onColorChange(\n            this.labelsAreShown,\n            this.icon ? true : false,\n            data.fillColor,\n            data.strokeColor\n          );\n          this.onOffsetLabelChange(\n            this.labelsAreShown,\n            data.offsetX,\n            data.offsetY\n          );\n        }\n      });\n    }, 250);\n  }\n\n  /**\n   * Open a dialog box to enter label and do something\n   * @param olGeometry geometry at draw end or selected geometry\n   * @param drawEnd event fired at drawEnd?\n   */\n  private openDrawDialog(olGeometry, isDrawEnd: boolean) {\n    setTimeout(() => {\n      // open the dialog box used to enter label\n      const dialogRef = this.dialog.open(DrawPopupComponent, {\n        disableClose: false,\n        data: { olGeometry: olGeometry, map: this.map }\n      });\n\n      // when dialog box is closed, get label and set it to geometry\n      dialogRef.afterClosed().subscribe((result) => {\n        // checks if the user clicked ok\n        if (dialogRef.componentInstance.confirmFlag) {\n          this.updateLabelOfOlGeometry(olGeometry, result.label);\n          this.updateLabelType(\n            olGeometry,\n            dialogRef.componentInstance.labelFlag\n          );\n          this.updateMeasureUnit(olGeometry, result.measureUnit);\n\n          if (!(olGeometry instanceof OlFeature)) {\n            this.updateFontSizeAndStyle(olGeometry, '15', FontType.Arial);\n            this.updateFillAndStrokeColor(\n              olGeometry,\n              'rgba(255,255,255,0.4)',\n              'rgba(143,7,7,1)'\n            );\n            this.updateOffset(\n              olGeometry,\n              0,\n              olGeometry instanceof OlPoint ? -15 : 0\n            );\n          }\n\n          isDrawEnd\n            ? this.onDrawEnd(olGeometry)\n            : this.onSelectDraw(olGeometry, result.label, [\n                dialogRef.componentInstance.labelFlag,\n                result.measureUnit\n              ]);\n          this.updateHeightTable();\n        }\n        // deletes the feature\n        else {\n          this.activeDrawingLayerSource\n            .getFeatures()\n            .forEach((drawingLayerFeature) => {\n              const geometry = drawingLayerFeature.getGeometry() as any;\n              if (olGeometry === geometry) {\n                this.activeDrawingLayerSource.removeFeature(\n                  drawingLayerFeature\n                );\n              }\n            });\n        }\n      });\n    }, 250);\n  }\n\n  /**\n   * Clear the draw source and track the geometry being draw\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onDrawEnd(olGeometry: OlGeometry, radius?: number) {\n    this.addFeatureToStore(olGeometry, radius);\n    this.clearLabelsOfOlGeometry(olGeometry);\n    this.activeStore.layer.ol.getSource().refresh();\n  }\n\n  private onModifyDraw(olGeometry) {\n    const entities = this.activeStore.all();\n\n    entities.forEach((entity) => {\n      const entityId = entity.properties.id;\n      const olGeometryId = olGeometry.ol_uid;\n\n      if (entityId === olGeometryId) {\n        if (entity.properties.labelType === LabelType.Coordinates) {\n          let longLat = DDtoDMS(\n            [entity.properties.longitude, entity.properties.latitude],\n            entity.properties.measureUnit as CoordinatesUnit\n          );\n          this.updateLabelOfOlGeometry(\n            olGeometry,\n            '(' + longLat[1] + ', ' + longLat[0] + ')'\n          );\n        } else if (entity.properties.labelType === LabelType.Length) {\n          if (olGeometry instanceof OlCircle) {\n            let circularPolygon = fromCircle(olGeometry, 10000);\n            const radius = metersToUnit(\n              this.getRadius(circularPolygon),\n              entity.properties.measureUnit as MeasureLengthUnit\n            );\n            const unit =\n              MeasureLengthUnitAbbreviation[entity.properties.measureUnit];\n            const radiusLabel =\n              'R: ' + radius.toFixed(2).toString() + ' ' + unit;\n            this.updateLabelOfOlGeometry(olGeometry, radiusLabel);\n          } else {\n            let olGeometryLength = measureOlGeometryLength(\n              olGeometry,\n              this.map.ol.getView().getProjection().getCode()\n            );\n            let measureUnit: any;\n            const temp: MeasureLengthUnit = entity.properties\n              .measureUnit as MeasureLengthUnit;\n            measureUnit =\n              MeasureLengthUnitAbbreviation[entity.properties.measureUnit];\n            olGeometryLength = metersToUnit(olGeometryLength, temp);\n            let lengthLabel =\n              olGeometry instanceof Polygon\n                ? 'P: ' +\n                  olGeometryLength.toFixed(2).toString() +\n                  ' ' +\n                  measureUnit\n                : olGeometryLength.toFixed(2).toString() + ' ' + measureUnit;\n            this.updateLabelOfOlGeometry(olGeometry, lengthLabel);\n          }\n        } else if (entity.properties.labelType === LabelType.Area) {\n          if (olGeometry instanceof OlCircle) {\n            let circularPolygon = fromCircle(olGeometry, 10000);\n            let circleArea = measureOlGeometryArea(\n              circularPolygon,\n              this.map.ol.getView().getProjection().getCode()\n            );\n            const unit =\n              MeasureAreaUnitAbbreviation[entity.properties.measureUnit];\n            const temp: MeasureAreaUnit = entity.properties\n              .measureUnit as MeasureAreaUnit;\n            circleArea = squareMetersToUnit(circleArea, temp);\n            const areaLabel = circleArea.toFixed(2).toString() + ' ' + unit;\n            this.updateLabelOfOlGeometry(olGeometry, areaLabel);\n          } else {\n            let olGeometryArea = measureOlGeometryArea(\n              olGeometry,\n              this.map.ol.getView().getProjection().getCode()\n            );\n            let measureUnit: any;\n            const temp: MeasureAreaUnit = entity.properties\n              .measureUnit as MeasureAreaUnit;\n            measureUnit =\n              MeasureAreaUnitAbbreviation[entity.properties.measureUnit];\n            olGeometryArea = squareMetersToUnit(olGeometryArea, temp);\n            const lengthLabel =\n              olGeometryArea.toFixed(2).toString() + ' ' + measureUnit;\n            this.updateLabelOfOlGeometry(olGeometry, lengthLabel);\n          }\n        } else {\n          this.updateLabelOfOlGeometry(olGeometry, entity.properties.draw);\n        }\n\n        this.updateLabelType(olGeometry, entity.properties.labelType);\n        this.updateMeasureUnit(olGeometry, entity.properties.measureUnit);\n        this.updateFontSizeAndStyle(\n          olGeometry,\n          entity.properties.fontStyle.split(' ')[0].replace('px', ''),\n          entity.properties.fontStyle.substring(\n            entity.properties.fontStyle.indexOf(' ') + 1\n          )\n        );\n        this.updateFillAndStrokeColor(\n          olGeometry,\n          entity.properties.drawingStyle.fill,\n          entity.properties.drawingStyle.stroke\n        );\n        this.updateOffset(\n          olGeometry,\n          entity.properties.offsetX,\n          entity.properties.offsetY\n        );\n        this.replaceFeatureInStore(entity, olGeometry);\n      }\n    });\n  }\n\n  private onSelectDraw(\n    olFeature: OlFeature<OlGeometry>,\n    label: string,\n    labelTypeAndUnit?\n  ) {\n    const entities = this.activeStore.all();\n\n    const olGeometry = olFeature.getGeometry() as any;\n    olGeometry.ol_uid = olFeature.get('id');\n\n    const olGeometryCoordinates = JSON.stringify(\n      olGeometry.getCoordinates()[0]\n    );\n\n    entities.forEach((entity) => {\n      const entityCoordinates = JSON.stringify(entity.geometry.coordinates[0]);\n      if (olGeometryCoordinates === entityCoordinates) {\n        const fontSize = olFeature\n          .get('fontStyle')\n          .split(' ')[0]\n          .replace('px', '');\n        const fontStyle = olFeature\n          .get('fontStyle')\n          .substring(olFeature.get('fontStyle').indexOf(' ') + 1);\n\n        const fillColor = olFeature.get('drawingStyle').fill;\n        const strokeColor = olFeature.get('drawingStyle').stroke;\n\n        const offsetX = olFeature.get('offsetX');\n        const offsetY = olFeature.get('offsetY');\n\n        const rad: number = entity.properties.rad\n          ? entity.properties.rad\n          : undefined;\n        this.updateLabelOfOlGeometry(olGeometry, label);\n        this.updateFontSizeAndStyle(olGeometry, fontSize, fontStyle);\n        this.updateFillAndStrokeColor(olGeometry, fillColor, strokeColor);\n        this.updateOffset(olGeometry, offsetX, offsetY);\n        this.updateLabelType(olGeometry, labelTypeAndUnit[0]);\n        this.updateMeasureUnit(olGeometry, labelTypeAndUnit[1]);\n        this.replaceFeatureInStore(entity, olGeometry, rad);\n      }\n    });\n  }\n\n  /**\n   * Add a feature with draw label to the store. The loading stragegy of the store\n   * will trigger and add the feature to the map.\n   * @internal\n   */\n  private addFeatureToStore(\n    olGeometry,\n    radius?: number,\n    feature?: FeatureWithDraw\n  ) {\n    let rad: number;\n    let center4326: Array<number>;\n    let point4326: Array<number>;\n    let lon4326: number;\n    let lat4326: number;\n\n    const featureId = feature ? feature.properties.id : olGeometry.ol_uid;\n    const projection = this.map.ol.getView().getProjection();\n\n    const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {\n      featureProjection: projection,\n      dataProjection: projection\n    }) as any;\n\n    if (olGeometry instanceof OlCircle || radius) {\n      if (radius) {\n        rad = radius;\n      } else {\n        geometry.type = 'Point';\n        geometry.coordinates = olGeometry.getCenter();\n        const extent4326 = transform(\n          [\n            olGeometry.getFlatCoordinates()[2],\n            olGeometry.getFlatCoordinates()[3]\n          ],\n          projection,\n          'EPSG:4326'\n        );\n        center4326 = transform(\n          [\n            olGeometry.getFlatCoordinates()[0],\n            olGeometry.getFlatCoordinates()[1]\n          ],\n          projection,\n          'EPSG:4326'\n        );\n        lon4326 = center4326[0];\n        lat4326 = center4326[1];\n        rad = getDistance(center4326, extent4326);\n        this.radiusFormControl.setValue(Math.round(rad));\n      }\n    }\n    if (this.activeDrawControl.radiusDrawEnd$.getValue()) {\n      rad = this.activeDrawControl.radiusDrawEnd$.getValue();\n    }\n\n    if (olGeometry instanceof OlPoint) {\n      point4326 = transform(\n        olGeometry.getFlatCoordinates(),\n        projection,\n        'EPSG:4326'\n      );\n      lon4326 = point4326[0];\n      lat4326 = point4326[1];\n    }\n\n    this.activeStore.update({\n      type: FEATURE,\n      geometry,\n      projection: projection.getCode(),\n      properties: {\n        id: featureId,\n        draw: olGeometry.get('_label'),\n        longitude: lon4326 ? lon4326 : null,\n        latitude: lat4326 ? lat4326 : null,\n        rad: rad ? rad : null,\n        fontStyle: olGeometry.get('fontStyle_'),\n        drawingStyle: {\n          fill: olGeometry.get('fillColor_'),\n          stroke: olGeometry.get('strokeColor_')\n        },\n        offsetX: olGeometry.get('offsetX_'),\n        offsetY: olGeometry.get('offsetY_'),\n        labelType: olGeometry.get('labelType_'),\n        measureUnit: olGeometry.get('measureUnit_')\n      },\n      meta: {\n        id: featureId\n      }\n    });\n    this.activeStore.setLayerExtent();\n    this.activeDrawControl.predefinedRadius$.next(undefined);\n    this.activeDrawControl.radiusDrawEnd$.next(undefined);\n  }\n\n  private buildForm() {\n    this.form = this.formBuilder.group({\n      fill: [''],\n      stroke: ['']\n    });\n  }\n\n  public setupLayer(isNewLayer?: boolean) {\n    setTimeout(() => {\n      const dialogRef = this.dialog.open(DrawLayerPopupComponent, {\n        disableClose: false\n      });\n      dialogRef.afterClosed().subscribe((label: string) => {\n        if (dialogRef.componentInstance.confirmFlag) {\n          this.activeStore.state.updateAll({ selected: false });\n          this.activeStore = new FeatureStore<FeatureWithDraw>([], {\n            map: this.map\n          });\n          this.activeDrawingLayerSource = new OlVectorSource();\n          this.activeDrawingLayer.opacity = 0;\n          this.deactivateDrawControl();\n          this.initStore(label, isNewLayer);\n          this.activeDrawControl = this.createDrawControl(\n            this.fillColor,\n            this.strokeColor,\n            this.strokeWidth\n          );\n          this.activeDrawControl.setGeometryType(this.currGeometryType);\n          this.toggleDrawControl();\n          this.stores.push(this.activeStore);\n          this.drawControls.push([\n            this.activeDrawingLayer.id,\n            this.activeDrawControl\n          ]);\n          this.drawControlsEvent.emit(this.drawControls);\n          this.layersIDEvent.emit(this.activeDrawingLayer.id);\n          this.isCreatingNewLayer = false;\n          if (!this.labelsAreShown) {\n            this.onToggleLabels();\n          }\n          this.activeLayerChange.emit(this.activeDrawingLayer);\n        } else {\n          this.select.value = this.activeDrawingLayer;\n          this.select.selectionChange.emit(this.activeDrawingLayer);\n        }\n      });\n    }, 250);\n  }\n\n  // HTML user interactions\n\n  /**\n   * Called when the user double-clicks the selected drawing\n   */\n  editLabelDrawing(feature) {\n    const olGeometryFeature = featureToOl(\n      feature,\n      this.map.ol.getView().getProjection().getCode()\n    );\n    this.openDrawDialog(olGeometryFeature, false);\n  }\n\n  openShorcutsDialog() {\n    this.dialog.open(DrawShorcutsComponent);\n  }\n\n  deleteDrawings() {\n    this.activeStore.deleteMany(this.selectedFeatures$.value);\n    this.selectedFeatures$.value.forEach((selectedFeature) => {\n      this.activeDrawingLayerSource\n        .getFeatures()\n        .forEach((drawingLayerFeature) => {\n          const geometry = drawingLayerFeature.getGeometry() as any;\n          if (selectedFeature.properties.id === geometry.ol_uid) {\n            this.activeDrawingLayerSource.removeFeature(drawingLayerFeature);\n          }\n        });\n    });\n    this.updateHeightTable();\n    this.activeStore.setLayerExtent();\n  }\n\n  /**\n   * Called when the user toggles the labels toggle\n   */\n  onToggleLabels() {\n    this.drawStyleService.toggleLabelsAreShown();\n    this.labelsAreShown = !this.labelsAreShown;\n    this.icon\n      ? this.elementStyle(this.labelsAreShown, true)\n      : this.elementStyle(this.labelsAreShown, false);\n    this.createDrawControl();\n  }\n\n  /**\n   * Called when the user toggles the Draw control is toggled\n   * @internal\n   */\n  onToggleDrawControl(toggleIsChecked: boolean) {\n    toggleIsChecked ? this.toggleDrawControl() : this.deactivateDrawControl();\n  }\n\n  onToggleFreehandMode(event: any) {\n    if (this.isCircle() && !event.checked) {\n      this.activeDrawControl.ispredefinedRadius$.next(true);\n      this.changeRadius(this.radiusFormControl.value);\n    } else {\n      this.activeDrawControl.setOlInteractionStyle(\n        createInteractionStyle(\n          this.fillColor,\n          this.strokeColor,\n          this.strokeWidth\n        )\n      );\n      this.activeDrawControl.ispredefinedRadius$.next(false);\n    }\n    this.freehandMode = event.checked;\n    this.activeDrawControl.freehand$.next(event.checked);\n    this.toggleDrawControl();\n  }\n\n  // User changes properties of a drawing element\n\n  /**\n   * Display the current layer with the current store and the current layerSource\n   */\n\n  public onLayerChange(currLayer?: VectorLayer) {\n    if (currLayer) {\n      this.activeStore.state.updateAll({ selected: false });\n      this.isCreatingNewLayer = false;\n      this.activeDrawingLayer.opacity = 0;\n      this.activeDrawingLayer = currLayer;\n      this.activeDrawingLayer.opacity = 1;\n      this.deactivateDrawControl();\n      if (!this.labelsAreShown) {\n        this.onToggleLabels();\n      }\n      this.activeStore = this.stores.find(\n        (store) => store.layer.id === this.activeDrawingLayer.id\n      );\n      this.activeDrawControl = this.drawControls.find(\n        (dc) => dc[0] === this.activeDrawingLayer.id\n      )[1];\n      this.activeDrawingLayerSource =\n        this.activeDrawControl.olDrawingLayerSource;\n      this.activeDrawControl.setGeometryType(this.currGeometryType);\n      this.toggleDrawControl();\n    } else {\n      this.setupLayer(true);\n    }\n    this.activeLayerChange.emit(this.activeDrawingLayer);\n  }\n\n  public createLayer(newTitle?, isNewLayer?) {\n    for (const layer of this.allLayers) {\n      let numberId = Number(layer.id.replace('igo-draw-layer', ''));\n      this.layerCounterID = Math.max(numberId, this.layerCounterID);\n    }\n    this.activeDrawingLayer = new VectorLayer({\n      isIgoInternalLayer: true,\n      id: 'igo-draw-layer' + ++this.layerCounterID,\n      title: isNewLayer\n        ? newTitle\n        : this.languageService.translate.instant('igo.geo.draw.drawing'),\n      zIndex: 200,\n      source: new FeatureDataSource(),\n      style: (feature, resolution) => {\n        return this.drawStyleService.createIndividualElementStyle(\n          feature,\n          resolution,\n          this.labelsAreShown,\n          feature.get('fontStyle'),\n          feature.get('drawingStyle').fill,\n          feature.get('drawingStyle').stroke,\n          feature.get('offsetX'),\n          feature.get('offsetY'),\n          this.map.projection,\n          this.icon\n        );\n      },\n      showInLayerList: true,\n      exportable: true,\n      browsable: false,\n      workspace: {\n        enabled: false\n      }\n    });\n\n    tryBindStoreLayer(this.activeStore, this.activeDrawingLayer);\n\n    tryAddLoadingStrategy(\n      this.activeStore,\n      new FeatureStoreLoadingStrategy({\n        motion: FeatureMotion.None\n      })\n    );\n\n    tryAddSelectionStrategy(\n      this.activeStore,\n      new FeatureStoreSelectionStrategy({\n        map: this.map,\n        motion: FeatureMotion.None,\n        many: true\n      })\n    );\n    this.activeStore.layer.visible = true;\n    this.activeStore.source.ol.on(\n      'removefeature',\n      (event: OlVectorSourceEvent<OlGeometry>) => {\n        const olGeometry = event.feature.getGeometry();\n        this.clearLabelsOfOlGeometry(olGeometry);\n      }\n    );\n  }\n\n  /**\n   * Called when the user changes the color in a color picker\n   * @param labelsAreShown wheter the labels are shown or not\n   * @param isAnIcon wheter the feature is an icon or not\n   * @param fillColor which is the filling color\n   * @param strokeColor which is the stroke color\n   */\n  onColorChange(\n    labelsAreShown: boolean,\n    isAnIcon: boolean,\n    fillColor: string,\n    strokeColor: string\n  ) {\n    if (this.selectedFeatures$.value.length > 0 && !isAnIcon) {\n      this.selectedFeatures$.value.forEach((feature) => {\n        let olFeature = featureToOl(\n          feature,\n          this.map.ol.getView().getProjection().getCode()\n        );\n        this.updateFillAndStrokeColor(olFeature, fillColor, strokeColor);\n\n        const entity = this.activeStore\n          .all()\n          .find((e) => e.meta.id === olFeature.getId());\n        entity.properties.drawingStyle.fill = olFeature.get('fillColor_');\n        entity.properties.drawingStyle.stroke = olFeature.get('strokeColor_');\n        this.activeStore.update(entity);\n      });\n    }\n\n    this.elementStyle(labelsAreShown, isAnIcon);\n    this.createDrawControl();\n  }\n\n  /**\n   * Called when the user changes the font size or/and style\n   * @param labelsAreShown wheter the labels are shown or not\n   * @param size the size of the font\n   * @param style the style of the font\n   */\n\n  onFontChange(labelsAreShown: boolean, size: string, style: FontType) {\n    if (this.selectedFeatures$.value.length > 0) {\n      this.selectedFeatures$.value.forEach((feature) => {\n        let olFeature = featureToOl(\n          feature,\n          this.map.ol.getView().getProjection().getCode()\n        );\n        this.updateFontSizeAndStyle(olFeature, size, style);\n        const entity = this.activeStore\n          .all()\n          .find((e) => e.meta.id === olFeature.getId());\n        entity.properties.fontStyle = olFeature.get('fontStyle_');\n        this.activeStore.update(entity);\n        olFeature = this.activeStore.layer.ol\n          .getSource()\n          .getFeatures()\n          .find((f) => f.getId() === entity.meta.id);\n        olFeature.setProperties({ fontStyle: entity.properties.fontStyle });\n        olFeature.changed();\n      });\n\n      this.fontSize = size;\n      this.fontStyle = style;\n\n      this.drawStyleService.setFontSize(size);\n      this.drawStyleService.setFontStyle(style);\n\n      this.elementStyle(labelsAreShown);\n    }\n  }\n\n  /**\n   * Called when the user changes the value of the horizontal/vertical offset\n   * @param labelsAreShown wheter the labels are shown or not\n   * @param offsetX horizontal offset of the label\n   * @param offsetY vertical offset of the label\n   */\n\n  onOffsetLabelChange(\n    labelsAreShown: boolean,\n    offsetX: number,\n    offsetY: number\n  ) {\n    if (this.selectedFeatures$.value.length > 0) {\n      this.selectedFeatures$.value.forEach((feature) => {\n        let olFeature = featureToOl(\n          feature,\n          this.map.ol.getView().getProjection().getCode()\n        );\n        this.updateOffset(olFeature, offsetX, offsetY);\n        const entity = this.activeStore\n          .all()\n          .find((e) => e.meta.id === olFeature.getId());\n        entity.properties.offsetX = olFeature.get('offsetX_');\n        entity.properties.offsetY = olFeature.get('offsetY_');\n        this.activeStore.update(entity);\n        olFeature = this.activeStore.layer.ol\n          .getSource()\n          .getFeatures()\n          .find((f) => f.getId() === entity.meta.id);\n        olFeature.setProperties({\n          offsetX: entity.properties.offsetX,\n          offsetY: entity.properties.offsetY\n        });\n        olFeature.changed();\n      });\n      this.elementStyle(labelsAreShown);\n    }\n  }\n\n  onIconChange(event?) {\n    this.icon = event;\n    this.drawStyleService.setIcon(this.icon);\n    this.elementStyle(true, this.icon);\n  }\n\n  /**\n   * Called when the user selects a new geometry type\n   * @param geometryType the geometry type selected by the user\n   */\n  onGeometryTypeChange(geometryType: Type) {\n    this.currGeometryType = geometryType;\n    this.activeDrawControl.setGeometryType(geometryType);\n    this.freehandMode\n      ? this.onToggleFreehandMode({ checked: true })\n      : this.onToggleFreehandMode({ checked: false });\n    this.toggleDrawControl();\n  }\n\n  // Updates the properties of olFeature inputted\n\n  /**\n   * Update the label of a geometry when a label is entered in a dialog box\n   * @param OlFeature the feature\n   * @param label the label\n   */\n  private updateLabelOfOlGeometry(OlFeature, label: string) {\n    OlFeature.setProperties(\n      {\n        _label: label\n      },\n      true\n    );\n  }\n\n  private updateFontSizeAndStyle(\n    olFeature: OlFeature<OlGeometry>,\n    fontSize: string,\n    fontStyle: string\n  ) {\n    olFeature.setProperties(\n      {\n        fontStyle_: `${fontSize}px ${fontStyle}`\n      },\n      true\n    );\n  }\n\n  private updateFillAndStrokeColor(\n    olFeature: OlFeature<OlGeometry>,\n    fillColor: string,\n    strokeColor: string\n  ) {\n    olFeature.setProperties(\n      {\n        fillColor_: fillColor,\n        strokeColor_: strokeColor\n      },\n      true\n    );\n  }\n\n  private updateOffset(\n    olFeature: OlFeature<OlGeometry>,\n    offsetX: number,\n    offsetY: number\n  ) {\n    olFeature.setProperties(\n      {\n        offsetX_: offsetX,\n        offsetY_: offsetY\n      },\n      true\n    );\n  }\n\n  private updateLabelType(\n    olFeature: OlFeature<OlGeometry>,\n    typeOfLabel: LabelType | [LabelType, LabelType]\n  ) {\n    olFeature.setProperties(\n      {\n        labelType_: typeOfLabel\n      },\n      true\n    );\n  }\n\n  private updateMeasureUnit(\n    olFeature: OlFeature<OlGeometry>,\n    measureUnit: MeasureLengthUnit | MeasureAreaUnit | CoordinatesUnit | []\n  ) {\n    olFeature.setProperties(\n      {\n        measureUnit_: measureUnit\n      },\n      true\n    );\n  }\n\n  // Updates values of the selected element on the HTML view\n\n  getFeatureFontSize(): string {\n    return this.selectedFeatures$.value.length > 0\n      ? this.selectedFeatures$.value[0].properties.fontStyle\n          .split(' ')[0]\n          .replace('px', '')\n      : '15';\n  }\n\n  getFeatureFontStyle() {\n    return this.selectedFeatures$.value.length > 0\n      ? this.selectedFeatures$.value[0].properties.fontStyle.substring(\n          this.selectedFeatures$.value[0].properties.fontStyle.indexOf(' ') + 1\n        )\n      : FontType.Arial;\n  }\n\n  getFeatureFillColor() {\n    return this.selectedFeatures$.value.length > 0\n      ? this.selectedFeatures$.value[0].properties.drawingStyle.fill\n      : 'rgba(255,255,255,0.4)';\n  }\n\n  getFeatureStrokeColor() {\n    return this.selectedFeatures$.value.length > 0\n      ? this.selectedFeatures$.value[0].properties.drawingStyle.stroke\n      : 'rgba(143,7,7,1)';\n  }\n\n  getFeatureOffsetX() {\n    return this.selectedFeatures$.value.length > 0\n      ? this.selectedFeatures$.value[0].properties.offsetX\n      : this.drawStyleService.getOffsetX();\n  }\n\n  getFeatureOffsetY() {\n    return this.selectedFeatures$.value.length > 0\n      ? this.selectedFeatures$.value[0].properties.offsetY\n      : '0';\n  }\n\n  get allFontStyles(): string[] {\n    return Object.values(FontType);\n  }\n\n  get allLayers() {\n    return this.map.layers.filter((layer) =>\n      String(layer.id).includes('igo-draw-layer')\n    );\n  }\n\n  updateHeightTable() {\n    // Check the amount of rows as a possible alternative\n    this.numberOfDrawings = this.activeStore.count$.getValue();\n    this.numberOfDrawings > 10\n      ? (this.tableTemplate.tableHeight = '35vh')\n      : (this.tableTemplate.tableHeight = 'auto');\n  }\n\n  updateActiveLayer() {\n    let currLayer = this.allLayers.find(\n      (layer) => layer.title === this.activeDrawingLayer.title\n    );\n    return currLayer ? currLayer : this.allLayers[0];\n  }\n\n  // Helper methods\n\n  /**\n   * Activate the correct control\n   */\n  private toggleDrawControl() {\n    this.deactivateDrawControl();\n    this.activateDrawControl();\n  }\n\n  /**\n   * Clear the tooltips of an OL geometry\n   * @param olGeometry OL geometry with tooltips\n   */\n  private clearLabelsOfOlGeometry(olGeometry) {\n    getTooltipsOfOlGeometry(olGeometry).forEach(\n      (olTooltip: OlOverlay | undefined) => {\n        if (olTooltip && olTooltip.getMap()) {\n          this.map.ol.removeOverlay(olTooltip);\n        }\n      }\n    );\n  }\n  /**\n   * Replace the feature in the store\n   * @param entity the entity to replace\n   * @param olGeometry the new geometry to insert in the store\n   */\n  private replaceFeatureInStore(\n    entity,\n    olGeometry: OlGeometry,\n    radius?: number\n  ) {\n    this.activeStore.delete(entity);\n    this.onDrawEnd(olGeometry, radius);\n  }\n\n  /**\n   * Deactivate the active draw control\n   */\n  private deactivateDrawControl() {\n    if (!this.activeDrawControl) {\n      return;\n    }\n\n    if (this.drawEnd$$) {\n      this.drawEnd$$.unsubscribe();\n    }\n\n    this.activeDrawControl.setOlMap(undefined);\n    this.drawControlIsActive = false;\n  }\n\n  /**\n   * Activate a given control\n   */\n  private activateDrawControl() {\n    this.drawControlIsDisabled = false;\n    this.drawControlIsActive = true;\n    this.drawEnd$$ = this.activeDrawControl.end$.subscribe(\n      (olGeometry: OlGeometry) => {\n        this.openDrawDialog(olGeometry, true);\n      }\n    );\n\n    this.activeDrawControl.modify$.subscribe((olGeometry: OlGeometry) => {\n      this.onModifyDraw(olGeometry);\n    });\n\n    if (!this.drawSelect$$) {\n      this.drawSelect$$ = this.activeDrawControl.select$.subscribe(\n        (olFeature: OlFeature<OlGeometry>) => {\n          this.openDrawDialog(olFeature, false);\n        }\n      );\n    }\n    this.activeDrawControl.setOlMap(this.map.ol, true);\n  }\n\n  /**\n   * get the geometry of design\n   *\n   */\n\n  isPoint() {\n    return this.activeDrawControl.getGeometryType() === this.geometryType.Point;\n  }\n\n  isLineString() {\n    return (\n      this.activeDrawControl.getGeometryType() === this.geometryType.LineString\n    );\n  }\n\n  isPolygon() {\n    return (\n      this.activeDrawControl.getGeometryType() === this.geometryType.Polygon\n    );\n  }\n\n  isCircle() {\n    return (\n      this.activeDrawControl.getGeometryType() === this.geometryType.Circle\n    );\n  }\n\n  /**\n   * The fonction to predefine the radius of the user\n   *\n   */\n\n  changeRadius(radius: number) {\n    let radiusMeters: number;\n\n    if (radius) {\n      this.measureUnit === MeasureLengthUnit.Meters\n        ? (radiusMeters = radius)\n        : (radiusMeters = radius * 1000);\n    } else {\n      radiusMeters = undefined;\n    }\n\n    const pointStyle = (feature: OlFeature<OlGeometry>, resolution: number) => {\n      const geom = feature.getGeometry() as OlPoint;\n      const coordinates = olproj.transform(\n        geom.getCoordinates(),\n        this.map.projection,\n        'EPSG:4326'\n      );\n\n      const radius =\n        radiusMeters / Math.cos((Math.PI / 180) * coordinates[1]) / resolution;\n      this.activeDrawControl.predefinedRadius$.next(radiusMeters);\n      return new OlStyle.Style({\n        image: new OlStyle.Circle({\n          radius: radius,\n          stroke: new OlStyle.Stroke({\n            width: 1,\n            color: 'rgba(143,7,7,1)'\n          }),\n          fill: new OlStyle.Fill({\n            color: 'rgba(255,255,255,0.4)'\n          })\n        })\n      });\n    };\n\n    this.activeDrawControl.setOlInteractionStyle(pointStyle);\n    this.toggleDrawControl();\n  }\n\n  onMeasureUnitChange(selectedMeasureUnit: MeasureLengthUnit) {\n    if (selectedMeasureUnit === this.measureUnit) {\n      return;\n    } else {\n      this.measureUnit = selectedMeasureUnit;\n      this.measureUnit === MeasureLengthUnit.Meters\n        ? this.radiusFormControl.setValue(this.radiusFormControl.value * 1000)\n        : this.radiusFormControl.setValue(this.radiusFormControl.value / 1000);\n    }\n  }\n\n  /**\n   * Recreates the style of the feature stored\n   */\n  private elementStyle(labelsAreShown: boolean, isAnIcon?) {\n    if (isAnIcon) {\n      this.activeStore.layer.ol.setStyle((feature, resolution) => {\n        return this.drawStyleService.createIndividualElementStyle(\n          feature,\n          resolution,\n          labelsAreShown,\n          feature.get('fontStyle'),\n          feature.get('drawingStyle').fill,\n          feature.get('drawingStyle').stroke,\n          feature.get('offsetX'),\n          feature.get('offsetY'),\n          this.map.projection,\n          this.icon\n        );\n      });\n    } else {\n      this.activeStore.layer.ol.setStyle((feature, resolution) => {\n        return this.drawStyleService.createIndividualElementStyle(\n          feature,\n          resolution,\n          labelsAreShown,\n          feature.get('fontStyle'),\n          feature.get('drawingStyle').fill,\n          feature.get('drawingStyle').stroke,\n          feature.get('offsetX'),\n          feature.get('offsetY'),\n          this.map.projection\n        );\n      });\n    }\n  }\n\n  private getRadius(olGeometry): number {\n    const length = getLength(olGeometry);\n    return Number(length / (2 * Math.PI));\n  }\n}\n","<div>\n  <div class=\"geometry-type-toggle mat-typography\">\n    <mat-button-toggle-group\n      (change)=\"onGeometryTypeChange($event.value)\"\n      [value]=\"geometryType.Point\"\n    >\n      <mat-button-toggle [value]=\"geometryType.Point\">\n        {{ 'igo.geo.draw.' + geometryType.Point | translate }}\n      </mat-button-toggle>\n\n      <mat-button-toggle [value]=\"geometryType.LineString\">\n        {{ 'igo.geo.draw.' + geometryType.LineString | translate }}\n      </mat-button-toggle>\n\n      <mat-button-toggle [value]=\"geometryType.Polygon\">\n        {{ 'igo.geo.draw.' + geometryType.Polygon | translate }}\n      </mat-button-toggle>\n\n      <mat-button-toggle [value]=\"geometryType.Circle\">\n        {{ 'igo.geo.draw.' + geometryType.Circle | translate }}\n      </mat-button-toggle>\n    </mat-button-toggle-group>\n  </div>\n\n  <div class=\"draw-options mat-typography\">\n    <mat-slide-toggle\n      [disabled]=\"drawControlIsDisabled\"\n      [checked]=\"drawControlIsActive\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDrawControl($event.checked)\"\n    >\n      {{ 'igo.geo.draw.drawControl' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      [checked]=\"labelsAreShown\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleLabels()\"\n    >\n      {{ 'igo.geo.draw.toggleMapTooltips' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      *ngIf=\"!isPoint()\"\n      [checked]=\"freehandMode\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleFreehandMode($event)\"\n    >\n      {{ 'igo.geo.draw.freehandMode' | translate }}\n    </mat-slide-toggle>\n\n    <div class=\"radius-unit\" *ngIf=\"isCircle()\">\n      <form class=\"radius-form\">\n        <mat-form-field class=\"radius\">\n          <input\n            matInput\n            type=\"number\"\n            min=\"0\"\n            placeholder=\"{{ 'igo.geo.spatialFilter.radius' | translate }}\"\n            [formControl]=\"radiusFormControl\"\n            [readonly]=\"this.freehandMode\"\n          />\n        </mat-form-field>\n      </form>\n\n      <mat-form-field class=\"unit-field\">\n        <mat-select\n          [value]=\"measureUnit\"\n          (selectionChange)=\"onMeasureUnitChange($event.value)\"\n        >\n          <mat-option\n            *ngFor=\"let measureUnit of measureUnits\"\n            [value]=\"measureUnit\"\n          >\n            {{ 'igo.geo.measure.' + measureUnit | translate }}\n          </mat-option>\n        </mat-select>\n      </mat-form-field>\n    </div>\n  </div>\n\n  <mat-divider></mat-divider>\n\n  <div class=\"layer-select-container\">\n    <mat-form-field class=\"layer-select\" subscriptSizing=\"dynamic\">\n      <mat-label>{{ 'igo.geo.draw.layer.title' | translate }}</mat-label>\n      <mat-select\n        #selectedLayer\n        (selectionChange)=\"onLayerChange(selectedLayer.value)\"\n        [value]=\"updateActiveLayer()\"\n      >\n        <mat-option *ngFor=\"let layer of allLayers\" [value]=\"layer\">\n          {{ layer.title }}\n        </mat-option>\n        <mat-option id=\"createNewLayer\">\n          {{ 'igo.geo.draw.layer.createNewLayer' | translate }}\n        </mat-option>\n      </mat-select>\n    </mat-form-field>\n    <button\n      *ngIf=\"activeDrawingLayer\"\n      mat-icon-button\n      [color]=\"activeDrawingLayer.visible ? 'primary' : 'default'\"\n      collapsibleButton\n      tooltip-position=\"below\"\n      matTooltipShowDelay=\"500\"\n      [matTooltip]=\"\n        activeDrawingLayer.visible\n          ? ('igo.geo.layer.hideLayer' | translate)\n          : ('igo.geo.layer.showLayer' | translate)\n      \"\n      (click)=\"activeDrawingLayer.visible = !activeDrawingLayer.visible\"\n    >\n      <mat-icon [svgIcon]=\"activeDrawingLayer.visible ? 'eye' : 'eye-off'\">\n      </mat-icon>\n    </button>\n  </div>\n  <mat-divider></mat-divider>\n  <div>\n    <button\n      *ngIf=\"activeStore.count$.getValue() > 0\"\n      class=\"deleteBtn\"\n      mat-icon-button\n      color=\"warn\"\n      tooltip-position=\"below\"\n      matTooltipShowDelay=\"500\"\n      [matTooltip]=\"'igo.geo.draw.delete' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      (click)=\"deleteDrawings()\"\n    >\n      <mat-icon svgIcon=\"delete\"></mat-icon>\n    </button>\n\n    <div>\n      <igo-entity-table\n        #table\n        class=\"table-compact\"\n        [store]=\"activeStore\"\n        [template]=\"tableTemplate\"\n      >\n      </igo-entity-table>\n    </div>\n  </div>\n\n  <div class=\"icon-options\">\n    <mat-form-field *ngIf=\"icons.length >= 1\">\n      <mat-label>{{ 'igo.geo.draw.icon' | translate }}</mat-label>\n      <mat-select>\n        <mat-select-trigger>\n          <div *ngIf=\"icon\" class=\"box\">\n            <img src=\"{{ icon }}\" />\n          </div>\n        </mat-select-trigger>\n        <mat-option value=\"\" (click)=\"onIconChange()\">{{\n          'igo.geo.draw.noIcon' | translate\n        }}</mat-option>\n        <mat-option\n          *ngFor=\"let icon_html of icons\"\n          [value]=\"icon_html\"\n          (click)=\"onIconChange(icon_html)\"\n        >\n          <div class=\"box\">\n            <img src=\"{{ icon_html }}\" />\n          </div>\n        </mat-option>\n      </mat-select>\n    </mat-form-field>\n  </div>\n\n  <div class=\"actions-container\">\n    <button\n      mat-icon-button\n      color=\"accent\"\n      disableRipple=\"true\"\n      (click)=\"openShorcutsDialog()\"\n    >\n      <mat-icon\n        class=\"shortcuts-icon\"\n        svgIcon=\"keyboard-outline\"\n        tooltip-position=\"below\"\n        matTooltipShowDelay=\"500\"\n        [matTooltip]=\"'igo.geo.draw.shortcuts' | translate\"\n      >\n      </mat-icon>\n    </button>\n\n    <button\n      *ngIf=\"selectedFeatures$.value.length\"\n      mat-raised-button\n      color=\"primary\"\n      (click)=\"openStyleModalDialog()\"\n      [matTooltip]=\"'igo.geo.style.styleModalTooltipSelected' | translate\"\n    >\n      {{ 'igo.geo.style.styleModal' | translate }}\n      <mat-icon\n        aria-hidden=\"false\"\n        iconPositionEnd\n        class=\"style-icon\"\n        svgIcon=\"palette\"\n        [matBadge]=\"selectedFeatures$.value.length\"\n        matBadgeColor=\"warn\"\n        matBadgeSize=\"medium\"\n      >\n      </mat-icon>\n    </button>\n  </div>\n</div>\n"]}