@flexem/fc-gui 3.0.0-alpha.91 → 3.0.0-alpha.92

package/elements/vector-graphics/sector-element.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"SectorElement":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"../base/conditional-dynamic-display-element","name":"ConditionalDynamicDisplayElement","line":6,"character":35},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"error","message":"Could not resolve type","line":10,"character":25,"context":{"typeName":"HTMLElement"}},{"__symbolic":"reference","module":"../../service","name":"PermissionChecker","line":10,"character":57},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":10,"character":98},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":10,"character":135},{"__symbolic":"reference","name":"string"}]}]}}}}]

package/elements/vector-graphics/straight-line-element.d.ts

@@ -0,0 +1,12 @@
+import { Size, Point } from '../../model';
+import { PermissionChecker } from '../../service';
+import { VariableCommunicator } from '../../communication';
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+import { StraightLineModel } from '../../model/straight-line/straight-line-model';
+import { VariableStore } from '../../config';
+export declare class StraightLineElement extends ConditionalDynamicDisplayElement {
+    readonly model: StraightLineModel;
+    constructor(element: HTMLElement, permissionChecker: PermissionChecker, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
+    getActualSize(): Size;
+    getActualLocation(): Point;
+}

package/elements/vector-graphics/straight-line-element.js

@@ -0,0 +1,19 @@
+import { Size } from '../../model';
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+export class StraightLineElement extends ConditionalDynamicDisplayElement {
+    constructor(element, permissionChecker, variableCommunicator, variableStore, signalRAppId) {
+        super(element, permissionChecker, variableCommunicator, variableStore, signalRAppId);
+    }
+    getActualSize() {
+        const arcPath = Snap(this.$element.find('path')[0]);
+        const b = arcPath.getBBox(true);
+        return new Size(b.width, b.height);
+    }
+    getActualLocation() {
+        const x = this.model.location.x;
+        const y = this.model.location.y;
+        return {
+            x, y
+        };
+    }
+}

package/elements/vector-graphics/straight-line-element.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"StraightLineElement":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"../base/conditional-dynamic-display-element","name":"ConditionalDynamicDisplayElement","line":7,"character":41},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"error","message":"Could not resolve type","line":11,"character":25,"context":{"typeName":"HTMLElement"}},{"__symbolic":"reference","module":"../../service","name":"PermissionChecker","line":11,"character":57},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":12,"character":30},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":12,"character":67},{"__symbolic":"reference","name":"string"}]}],"getActualSize":[{"__symbolic":"method"}],"getActualLocation":[{"__symbolic":"method"}]}}}}]

package/elements/video/video-element.d.ts

@@ -0,0 +1,31 @@
+import { Injector } from '@angular/core';
+import { PermissionChecker } from '../../service';
+import { VariableCommunicator } from '../../communication';
+import { ConditionalDisplayElement } from '../base/conditional-display-element';
+import { VideoModel } from '../../model/video/video.model';
+import { VideoService } from '../../service';
+import { Size } from '../../model';
+import { VariableStore } from '../../config';
+export declare class VideoElement extends ConditionalDisplayElement {
+    private readonly videoService;
+    private readonly guiSize;
+    private readonly svgRootClass;
+    readonly model: VideoModel;
+    private isMobileMode;
+    private readonly localization;
+    private videoId;
+    private isShow;
+    private videoPlayer;
+    private refreshTimer;
+    private isFullscreen;
+    private videoUrl;
+    constructor(element: HTMLElement, injector: Injector, permissionChecker: PermissionChecker, variableCommunicator: VariableCommunicator, variableStore: VariableStore, videoService: VideoService, guiSize: Size, svgRootClass: string, signalRAppId: string);
+    dispose(): void;
+    hide(): void;
+    show(): void;
+    private init;
+    private initVideo;
+    private addVideoAddressToolTip;
+    private setAndroidVideo;
+    private setIosVideo;
+}

package/elements/video/video-element.js

@@ -0,0 +1,209 @@
+import { ConditionalDisplayElement } from '../base/conditional-display-element';
+import { Guid } from '../../utils/guid';
+import { DisplayMode, GlobalSettings } from '../../settings';
+import { TextElementModal } from '../shared/text/text-element';
+import { LOCALIZATION } from '../../localization';
+import { isNil } from 'lodash';
+export class VideoElement extends ConditionalDisplayElement {
+    constructor(element, injector, permissionChecker, variableCommunicator, variableStore, videoService, guiSize, svgRootClass, signalRAppId) {
+        super(element, permissionChecker, variableCommunicator, variableStore, signalRAppId);
+        this.videoService = videoService;
+        this.guiSize = guiSize;
+        this.svgRootClass = svgRootClass;
+        this.videoId = '';
+        this.isFullscreen = false;
+        this.isMobileMode = DisplayMode.Mobile === injector.get(GlobalSettings).displayMode;
+        this.localization = injector.get(LOCALIZATION);
+        this.init();
+    }
+    dispose() {
+        if (this.videoPlayer && typeof this.videoPlayer.stop === 'function') {
+            this.videoPlayer.stop();
+        }
+        $('div.' + this.svgRootClass + ' video').each(function () {
+            $(this).remove();
+        });
+    }
+    hide() {
+        super.hide();
+        this.isShow = false;
+        if (!isNil(this.videoId) && this.videoId !== '') {
+            setTimeout(() => {
+                $('#' + this.videoId).hide();
+            }, 0);
+        }
+    }
+    show() {
+        super.show();
+        this.isShow = true;
+        setTimeout(() => {
+            $('#' + this.videoId).show();
+        }, 0);
+    }
+    init() {
+        this.rootElement.selectAll('*').remove();
+        if (!this.model.videoTag) {
+            this.addVideoAddressToolTip(this.localization.unconfiguredVideoAddress);
+            return;
+        }
+        this.videoId = Guid.newGuid().toString('n');
+        this.rootElement.append('rect').attr('id', 'rect' + this.videoId).attr('fill', 'transparent')
+            .attr('width', this.model.size.width)
+            .attr('height', this.model.size.height);
+        this.videoService.getVideoUrl(this.model.videoTag).then(result => {
+            this.videoUrl = result.url;
+            this.initVideo(result.url, this.videoId);
+        }).catch(() => {
+            throw new Error('Failure of the videoService');
+        });
+    }
+    initVideo(videoUrl, videoId) {
+        const patt = /https:.+.m3u8/;
+        if (videoUrl.indexOf('http:') !== -1) {
+            videoUrl = videoUrl.replace('http:', 'https:');
+        }
+        if (!patt.test(videoUrl)) {
+            let videoToolTip = this.localization.invalidVideoAddress;
+            if (isNil(videoUrl) || videoUrl === '') {
+                videoToolTip = this.localization.unconfiguredVideoAddress;
+            }
+            this.addVideoAddressToolTip(videoToolTip);
+            return;
+        }
+        const isAndroid = !!navigator.userAgent.match(/(Android)/i);
+        const isIos = !!navigator.userAgent.match(/(Mac)/i);
+        const currentRect = this.$element.find('rect#rect' + videoId).first();
+        if (!currentRect.length) {
+            return;
+        }
+        const clientRect = currentRect[0].getBoundingClientRect();
+        const chartWidth = clientRect.width;
+        const chartHeight = clientRect.height;
+        const left = this.model.location.x / this.guiSize.width * $('.' + this.svgRootClass).find('.svg-content').width();
+        const top = this.model.location.y / this.guiSize.height * $('.' + this.svgRootClass).find('.svg-content').height();
+        const scareX = this.model.location.x / this.guiSize.width;
+        const scareY = this.model.location.y / this.guiSize.height;
+        if (isIos) {
+            videoUrl = videoUrl + '#t=1';
+        }
+        const preload = isIos ? ' preload=\'metadata\'' : '';
+        let videoHtml = `<video scareX="${scareX}"
+                scareY="${scareY}" id="${videoId}" ${preload} src="${videoUrl}" width="${chartWidth}" height="${chartHeight}"
+                style="position: absolute;top:${top}px;left:${left}px;object-fit:fill;z-index:0;"
+                playsInline webkit-playsinline `;
+        if (this.isMobileMode) {
+            if (isAndroid) {
+                videoHtml += ' autoplay muted></video>';
+            }
+            else {
+                videoHtml += ' controls muted></video>';
+            }
+        }
+        else {
+            videoHtml += ' controls autoplay muted></video>';
+        }
+        $('.' + this.svgRootClass).find('.svg-content').append(videoHtml);
+        if (this.isShow === false) {
+            $('#' + this.videoId).hide();
+        }
+        setTimeout(() => {
+            if (isAndroid) {
+                this.setAndroidVideo(videoId);
+            }
+            else if (isIos) {
+                this.setIosVideo(this.videoUrl, videoId);
+            }
+            this.videoPlayer = new EZUIPlayer(videoId);
+        }, 1000);
+        const style = document.createElement('style');
+        style.innerHTML = `#${videoId}::-webkit-media-controls-enclosure {
+            display: none;
+        }`;
+        document.head.append();
+    }
+    addVideoAddressToolTip(videoToolTip) {
+        const size = this.model.size;
+        this.rootElement.append('image')
+            .attr('width', size.width)
+            .attr('height', size.height)
+            .attr('xlink:href', 'assets/img/video.jpg')
+            .attr('preserveAspectRatio', 'none')
+            .attr('crossorigin', 'anonymous');
+        const font = {
+            isUnderline: false,
+            isBold: false,
+            isItalic: false,
+            fontSize: '16px',
+            fontFamily: 'Microsoft YaHei',
+            color: '#fff',
+            textAlign: 'center'
+        };
+        const textElement = new TextElementModal(videoToolTip, font, size.width, size.height);
+        this.$element.append(textElement.Element);
+    }
+    setAndroidVideo(videoId) {
+        const videoElement = $('#' + videoId);
+        let preHeight = videoElement.height();
+        let preWidth = videoElement.width();
+        let preTop = videoElement.css('top');
+        let preLeft = videoElement.css('left');
+        const { StatusBar } = window;
+        videoElement.on('click', () => {
+            if (!this.isFullscreen) {
+                if (StatusBar) {
+                    StatusBar.hide();
+                }
+                preHeight = videoElement.height();
+                preWidth = videoElement.width();
+                preTop = videoElement.css('top');
+                preLeft = videoElement.css('left');
+                const width = document.documentElement.clientWidth;
+                const height = document.documentElement.clientHeight;
+                videoElement.css('object-fit', 'contain');
+                videoElement.css('background', '#000000');
+                videoElement.css('width', width + 'px');
+                videoElement.css('height', height + 'px');
+                videoElement.css('left', '0px');
+                videoElement.css('top', '0px');
+                videoElement.css('z-index', '99');
+                videoElement.css('position', 'fixed');
+                this.isFullscreen = true;
+                try {
+                    screen.orientation.lock(screen.orientation.type);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+            else {
+                videoElement.css('object-fit', 'fill');
+                videoElement.css('width', preWidth + 'px');
+                videoElement.css('height', preHeight + 'px');
+                videoElement.css('left', preLeft);
+                videoElement.css('top', preTop);
+                videoElement.css('z-index', '0');
+                videoElement.css('position', 'absolute');
+                this.isFullscreen = false;
+                try {
+                    if (screen.orientation.type.includes('portrait')) {
+                        StatusBar.show();
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+        });
+    }
+    setIosVideo(videoUrl, videoId) {
+        const video = $('#' + this.videoId);
+        video.on('webkitendfullscreen', () => {
+            video.remove();
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+            this.refreshTimer = setTimeout(() => {
+                this.initVideo(videoUrl, videoId);
+            }, 500);
+        });
+    }
+}

package/elements/video/video-element.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"VideoElement":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"../base/conditional-display-element","name":"ConditionalDisplayElement","line":15,"character":34},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"error","message":"Could not resolve type","line":27,"character":25,"context":{"typeName":"HTMLElement"}},{"__symbolic":"reference","module":"@angular/core","name":"Injector","line":28,"character":18},{"__symbolic":"reference","module":"../../service","name":"PermissionChecker","line":29,"character":27},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":30,"character":30},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":31,"character":23},{"__symbolic":"reference","module":"../../service","name":"VideoService","line":32,"character":39},{"__symbolic":"reference","module":"../../model","name":"Size","line":33,"character":34},{"__symbolic":"reference","name":"string"},{"__symbolic":"reference","name":"string"}]}],"dispose":[{"__symbolic":"method"}],"hide":[{"__symbolic":"method"}],"show":[{"__symbolic":"method"}],"init":[{"__symbolic":"method"}],"initVideo":[{"__symbolic":"method"}],"addVideoAddressToolTip":[{"__symbolic":"method"}],"setAndroidVideo":[{"__symbolic":"method"}],"setIosVideo":[{"__symbolic":"method"}]}}}}]

package/elements/view-operation/view-operation.element.d.ts

@@ -0,0 +1,36 @@
+import { Injector, ElementRef } from '@angular/core';
+import { BsModalService } from 'ngx-bootstrap/modal';
+import { Localization } from '../../localization';
+import { GraphStore, VariableStore } from '../../config';
+import { ViewOperationElementModel } from '../../model';
+import { PermissionChecker, OperationRecordService } from '../../service';
+import { VariableCommunicator } from '../../communication';
+import { ConditionalEnableElement } from '../base/conditional-enable-element';
+import { PopupViewService } from '../../view/popup-view.service';
+import { SecurityChecker } from '../../security';
+export declare class ViewOperationElement extends ConditionalEnableElement {
+    private readonly modalService;
+    private readonly graphStore;
+    private readonly operationRecordService;
+    private readonly securityChecker;
+    private readonly popupViewService;
+    private readonly hostContainerId;
+    private readonly el;
+    protected model: ViewOperationElementModel;
+    private readonly logger;
+    private readonly viewService;
+    private graphStateElement?;
+    private touchedScreenX;
+    private touchedScreenY;
+    constructor(element: HTMLElement, injector: Injector, modalService: BsModalService, variableCommunicator: VariableCommunicator, variableStore: VariableStore, graphStore: GraphStore, permissionChecker: PermissionChecker, operationRecordService: OperationRecordService, securityChecker: SecurityChecker, localization: Localization, popupViewService: PopupViewService, hostContainerId: string, el: ElementRef, signalRAppId: string);
+    private initElement;
+    private switchToState;
+    private initGraph;
+    private checkElementPassword;
+    private executeViewOperation;
+    private toggleView;
+    private popView;
+    private closeView;
+    private moveView;
+    private recordViewOperation;
+}

package/elements/view-operation/view-operation.element.js

@@ -0,0 +1,202 @@
+import { LOGGER_SERVICE_TOKEN } from '../../logger';
+import * as d3 from 'd3-selection';
+import { drag } from 'd3-drag';
+import { ViewOperationType } from '../../model';
+import { ConditionalEnableElement } from '../base/conditional-enable-element';
+import { GraphStateElement } from '../shared/graph/graph-state-element';
+import { AlertModalComponent } from '../../modal/alert/alert-modal.component';
+import { ConfirmOperationModalComponent } from '../../modal/confirm-operation/confirm-operation-modal.component';
+import { VerifyPasswordModalComponent } from '../../modal/verify-password/verify-password-modal.component';
+import { ViewService } from '../../view/view.service';
+export class ViewOperationElement extends ConditionalEnableElement {
+    constructor(element, injector, modalService, variableCommunicator, variableStore, graphStore, permissionChecker, operationRecordService, securityChecker, localization, popupViewService, hostContainerId, el, signalRAppId) {
+        super(element, permissionChecker, variableCommunicator, variableStore, localization, signalRAppId);
+        this.modalService = modalService;
+        this.graphStore = graphStore;
+        this.operationRecordService = operationRecordService;
+        this.securityChecker = securityChecker;
+        this.popupViewService = popupViewService;
+        this.hostContainerId = hostContainerId;
+        this.el = el;
+        this.touchedScreenX = 0;
+        this.touchedScreenY = 0;
+        this.logger = injector.get(LOGGER_SERVICE_TOKEN);
+        this.viewService = injector.get(ViewService);
+        this.initElement();
+    }
+    initElement() {
+        const width = this.model.size.width;
+        const height = this.model.size.height;
+        this.initGraph(width, height);
+        this.rootElement.append('rect').attr('id', 'StateFrame').attr('width', width).attr('height', height).attr('fill', 'transparent');
+        const $dateTimeText = this.$element.find('text').last();
+        const fontStyle = this.model.label.font.fontStyle;
+        $dateTimeText.css('font', fontStyle + ',msyh');
+        this.switchToState(0);
+        this.rootElement.on('mousedown', () => {
+            if (!this.isInitialized) {
+                return;
+            }
+            this.switchToState(1);
+            d3.event.preventDefault();
+            if (!this.isEnable) {
+                const message = !this.isGrantedPermission ? this.localization.permissiontip : this.localization.conditionIsNotMetTip;
+                const modalRef = this.modalService.show(AlertModalComponent, { initialState: { alermMessage: message }, backdrop: 'static', class: 'gui-modal-dialog-position', animated: false });
+                const onClosedSub = modalRef.content.onClosed.subscribe(() => {
+                    modalRef.hide();
+                    onClosedSub.unsubscribe();
+                });
+                return;
+            }
+        });
+        this.rootElement.on('mouseup', () => {
+            this.switchToState(0);
+            d3.event.preventDefault();
+            if (!this.isInitialized || !this.isEnable) {
+                return;
+            }
+            if (this.model.useSecurity) {
+                const modalRef = this.modalService.show(ConfirmOperationModalComponent, {
+                    backdrop: 'static', class: 'gui-modal-dialog-position', animated: false
+                });
+                const onClosedSub = modalRef.content.onClosed.subscribe(result => {
+                    modalRef.hide();
+                    onClosedSub.unsubscribe();
+                    if (result) {
+                        this.checkElementPassword();
+                    }
+                });
+            }
+            else {
+                this.checkElementPassword();
+            }
+        });
+        if (this.model.operationType === ViewOperationType.ControlView) {
+            this.rootElement.style('cursor', 'move');
+            this.rootElement.call(drag().on('start', () => {
+                if (!this.isEnable) {
+                    this.rootElement.style('cursor', 'hand');
+                    return;
+                }
+                if (!d3.event || !d3.event.sourceEvent) {
+                    this.logger.error('[GUI]Failed to get DragEvent', d3.event);
+                    return;
+                }
+                if (d3.event.sourceEvent.type === 'touchstart' && d3.event.sourceEvent.touches.length) {
+                    this.touchedScreenX = d3.event.sourceEvent.touches[0].screenX;
+                    this.touchedScreenY = d3.event.sourceEvent.touches[0].screenY;
+                }
+            }).on('drag', () => {
+                if (!this.isEnable) {
+                    this.rootElement.style('cursor', 'hand');
+                    return;
+                }
+                if (!d3.event || !d3.event.sourceEvent) {
+                    this.logger.error('[GUI]Failed to get DragEvent', d3.event);
+                    return;
+                }
+                if (d3.event.sourceEvent.type === 'mousemove') {
+                    this.moveView(d3.event.sourceEvent.movementX, d3.event.sourceEvent.movementY);
+                }
+                else if (d3.event.sourceEvent.type === 'touchmove' && d3.event.sourceEvent.touches.length) {
+                    const movementX = d3.event.sourceEvent.touches[0].screenX - this.touchedScreenX;
+                    const movementY = d3.event.sourceEvent.touches[0].screenY - this.touchedScreenY;
+                    this.touchedScreenX = d3.event.sourceEvent.touches[0].screenX;
+                    this.touchedScreenY = d3.event.sourceEvent.touches[0].screenY;
+                    this.moveView(movementX, movementY);
+                }
+            }).on('end', () => this.switchToState(0)));
+        }
+        else {
+            this.rootElement.style('cursor', 'hand');
+        }
+    }
+    switchToState(stateId) {
+        if (this.graphStateElement) {
+            this.graphStateElement.switchToState(stateId);
+        }
+    }
+    initGraph(width, height) {
+        if (this.model.useGraph === true) {
+            this.graphStateElement = new GraphStateElement(this.model.graphSetting, width, height, this.graphStore, this.logger);
+            this.$element.prepend(this.graphStateElement.Element);
+            this.graphStateElement.switchToState(0);
+        }
+    }
+    checkElementPassword() {
+        if (this.model.enablePassword) {
+            const modalRef = this.modalService.show(VerifyPasswordModalComponent, { initialState: { securityChecker: this.securityChecker }, backdrop: 'static', class: 'gui-modal-dialog-position', animated: false });
+            const onClosedSub = modalRef.content.onClosed.subscribe(result => {
+                modalRef.hide();
+                onClosedSub.unsubscribe();
+                if (result) {
+                    this.executeViewOperation();
+                }
+            });
+        }
+        else {
+            this.executeViewOperation();
+        }
+    }
+    executeViewOperation() {
+        let operationType = this.model.version >= 5 ? this.model.operationType : ViewOperationType.ToggleView;
+        operationType = operationType === undefined ? ViewOperationType.ToggleView : operationType;
+        switch (operationType) {
+            case ViewOperationType.ToggleView:
+                this.toggleView();
+                break;
+            case ViewOperationType.PopupView:
+                this.popView();
+                break;
+            case ViewOperationType.CloseView:
+                this.closeView();
+                break;
+        }
+    }
+    toggleView() {
+        const viewIndex = this.model.viewIndex;
+        if (null != viewIndex) {
+            const toggleView = this.viewService.toggleViews.get(this.el);
+            if (!toggleView) {
+                return;
+            }
+            toggleView(viewIndex, this.hostContainerId, this.el).subscribe(() => this.recordViewOperation(), error => this.logger.error(`ToggleView(${viewIndex}) failed. `, error));
+        }
+        else {
+            this.logger.error('[GUI]Toggle View:invalid view index');
+        }
+    }
+    popView() {
+        const viewIndex = this.model.viewIndex;
+        if (null != viewIndex) {
+            this.popupViewService.popView(viewIndex, this.hostContainerId, this.el).subscribe(() => this.recordViewOperation(), error => this.logger.error(`ToggleView(${viewIndex}) failed. ${error}`));
+            $(`#${this.hostContainerId} video`)
+                .addClass('video-hidden')
+                .css('visibility', 'hidden');
+        }
+        else {
+            this.logger.error('[GUI]Toggle View:invalid view index');
+        }
+    }
+    closeView() {
+        this.popupViewService.closeView();
+        if ($(`#${this.hostContainerId} > svg > svg`).length === 0) {
+            $(`#${this.hostContainerId} .video-hidden`)
+                .removeClass('video-hidden')
+                .css('visibility', 'visible');
+        }
+        this.recordViewOperation();
+    }
+    moveView(movementX, movementY) {
+        if (isNaN(movementX) || isNaN(movementY)) {
+            return;
+        }
+        this.popupViewService.moveView(movementX, movementY);
+        this.recordViewOperation();
+    }
+    recordViewOperation() {
+        if (this.model.isRecordOperation) {
+            this.operationRecordService.record({ operationDescription: this.model.operationDescription });
+        }
+    }
+}

package/elements/view-operation/view-operation.element.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ViewOperationElement":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"../base/conditional-enable-element","name":"ConditionalEnableElement","line":20,"character":42},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"error","message":"Could not resolve type","line":31,"character":25,"context":{"typeName":"HTMLElement"}},{"__symbolic":"reference","module":"@angular/core","name":"Injector","line":31,"character":48},{"__symbolic":"reference","module":"ngx-bootstrap/modal","name":"BsModalService","line":32,"character":39},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":33,"character":30},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":34,"character":23},{"__symbolic":"reference","module":"../../config","name":"GraphStore","line":35,"character":37},{"__symbolic":"reference","module":"../../service","name":"PermissionChecker","line":36,"character":27},{"__symbolic":"reference","module":"../../service","name":"OperationRecordService","line":37,"character":49},{"__symbolic":"reference","module":"../../security","name":"SecurityChecker","line":38,"character":42},{"__symbolic":"reference","module":"../../localization","name":"Localization","line":39,"character":22},{"__symbolic":"reference","module":"../../view/popup-view.service","name":"PopupViewService","line":40,"character":43},{"__symbolic":"reference","name":"string"},{"__symbolic":"reference","module":"@angular/core","name":"ElementRef","line":42,"character":29},{"__symbolic":"reference","name":"string"}]}],"initElement":[{"__symbolic":"method"}],"switchToState":[{"__symbolic":"method"}],"initGraph":[{"__symbolic":"method"}],"checkElementPassword":[{"__symbolic":"method"}],"executeViewOperation":[{"__symbolic":"method"}],"toggleView":[{"__symbolic":"method"}],"popView":[{"__symbolic":"method"}],"closeView":[{"__symbolic":"method"}],"moveView":[{"__symbolic":"method"}],"recordViewOperation":[{"__symbolic":"method"}]}}}}]

package/elements/weather/weater-element.d.ts

@@ -0,0 +1,38 @@
+import { ConditionalDisplayElement } from '../base/conditional-display-element';
+import { WeatherModel } from '../../model/weather/weather.model';
+import { Injector } from '@angular/core';
+import { PermissionChecker } from '../../service';
+import { VariableCommunicator } from '../../communication/variable';
+import { VariableStore } from '../../config/variable';
+import { WeatherService } from '../../service';
+import { LoggerService } from '../../logger';
+export declare class WeatherElement extends ConditionalDisplayElement {
+    private readonly weatherService;
+    model: WeatherModel;
+    id: number;
+    private readonly localization;
+    protected readonly logger: LoggerService;
+    timer: any;
+    constructor(element: HTMLElement, injector: Injector, permissionChecker: PermissionChecker, variableCommunicator: VariableCommunicator, variableStore: VariableStore, weatherService: WeatherService, signalRAppId: string);
+    dispose(): void;
+    private initWeatherInfo;
+    private clear;
+    private handleNotSupported;
+    private handleGettingAddress;
+    private handleNoAddress;
+    private handleUnusualCommon;
+    private handleNormal;
+    getRainPath(): string;
+    getLocPath(): string;
+    getWindPath(): string;
+    getUnusualIconPath(): string;
+    private buildBackgroudRect;
+    private buildTemperatureGroup;
+    private buildWeather;
+    private buildLocGroup;
+    private buildWindGroup;
+    private buildWeatherText;
+    private buildUnusualTipIcon;
+    private buildUnusualTipText;
+    private appendWeatherSvg;
+}