@flexem/fc-gui 3.0.0-alpha.3 → 3.0.0-alpha.32

package/model/meter/meter.d.ts

@@ -10,4 +10,8 @@ export interface Meter extends ReadableModel {
     readonly radius: number;
     readonly min: number;
     readonly max: number;
+    readonly masterDivisionNumber: number;
+    readonly subDivisionNumber: number;
+    readonly integerDigits: number;
+    readonly fractionDigits: number;
 }

package/model/numerical-display/numerical-display.d.ts

@@ -12,6 +12,7 @@ export interface NumericalDisplay extends ReadableModel, SecurityModel {
     readonly textAlign: string;
     readonly accessPermission: any;
     dataType: number;
+    fBoxDataType: number;
     readonly integerDigits: number;
     readonly fractionDigits: number;
     readonly enableNumericalOperation: boolean;
@@ -24,4 +25,5 @@ export interface NumericalDisplay extends ReadableModel, SecurityModel {
     readonly showVariableText?: boolean;
     readonly variableText?: any;
     readonly displayDataType?: DisplayDataType;
+    readonly enableDataParsed?: boolean;
 }

package/model/ring-graph/ring-graph.model.d.ts

@@ -22,4 +22,12 @@ export interface RingGraphModel extends ConditionalDisplayModel {
     readonly alarmRange?: AlarmRangeModel;
     readonly showPercentage: boolean;
     readonly percentageFont?: Font;
+    readonly minVariable?: any;
+    readonly maxVariable?: any;
+    readonly minValueType?: any;
+    readonly maxValueType?: any;
+    readonly masterDivisionNumber: number;
+    readonly subDivisionNumber: number;
+    readonly integerDigits: number;
+    readonly fractionDigits: number;
 }

package/model/shared/condition/bit-condition-item-observer.d.ts

@@ -8,7 +8,7 @@ export declare class BitConditionItemObserver extends ConditionItemObserver {
     private currentValue;
     private binary;
     constructor(bitConditon: BitConditionModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
-    requestData(): void;
+    requestData(appId: string): void;
     private requestconditionEffectiveValue;
     getIsConditionEffective(): boolean;
 }

package/model/shared/condition/bit-condition-item-observer.js

@@ -9,14 +9,14 @@ export class BitConditionItemObserver extends ConditionItemObserver {
         this.bitConditon = bitConditon;
         this.variableCommunicator = variableCommunicator;
     }
-    requestData() {
+    requestData(appId) {
         if (!this.bitConditon) {
             throw new Error('BitConditionModel cannot be null.');
         }
         if (this.variableName) {
             this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
                 if (variableValue.state === VariableStateEnum.Normal) {
-                    this.requestconditionEffectiveValue(this.variableCommunicator);
+                    this.requestconditionEffectiveValue(this.variableCommunicator, appId);
                 }
                 else {
                     this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
@@ -24,8 +24,8 @@ export class BitConditionItemObserver extends ConditionItemObserver {
             });
         }
     }
-    requestconditionEffectiveValue(variableCommunicator) {
-        variableCommunicator.openVariable(this.variableName).subscribe(value => {
+    requestconditionEffectiveValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.variableName, appId).subscribe(value => {
             if (this.bitConditon.isBitwiseIndex) {
                 const maxBitIndex = 31;
                 this.binary = new Binary(value.value, maxBitIndex + 1);

package/model/shared/condition/condition-items-result-observer.d.ts

@@ -11,6 +11,6 @@ export declare class ConditionItemsResultObserver implements ConditionItemsObser
     readonly conditionResultChanged: EventEmitter<ConditionControlResultValue>;
     private conditionResults;
     constructor(sourceConditionItems: ConditionItemModel[], variableCommunicator: VariableCommunicator, variableStore: VariableStore);
-    requestData(): void;
+    requestData(appId: string): void;
     private emitConditionResult;
 }

package/model/shared/condition/condition-items-result-observer.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from '@angular/core';
+import { sortBy } from 'lodash';
 import { ConditionType } from './condition-type';
 import { BitConditionItemObserver } from './bit-condition-item-observer';
 import { RelationConditionResult } from './relation-condition-result';
@@ -12,7 +13,7 @@ export class ConditionItemsResultObserver {
         this.conditionResultChanged = new EventEmitter();
         this.conditionResults = new Map();
     }
-    requestData() {
+    requestData(appId) {
         if (null == this.sourceConditionItems || !this.sourceConditionItems.length) {
             return;
         }
@@ -25,10 +26,10 @@ export class ConditionItemsResultObserver {
                         if (this.conditionResults.has(conditionItems.indexOf(item))) {
                             this.conditionResults.delete(conditionItems.indexOf(item));
                         }
-                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(item.relationType, itemResult));
+                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
                         this.emitConditionResult();
                     });
-                    bitItem.requestData();
+                    bitItem.requestData(appId);
                     break;
                 case ConditionType.Word:
                     const wordItem = new WordConditionItemObserver(item.condition, this.variableCommunicator, this.variableStore);
@@ -36,10 +37,10 @@ export class ConditionItemsResultObserver {
                         if (this.conditionResults.has(conditionItems.indexOf(item))) {
                             this.conditionResults.delete(conditionItems.indexOf(item));
                         }
-                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(item.relationType, itemResult));
+                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
                         this.emitConditionResult();
                     });
-                    wordItem.requestData();
+                    wordItem.requestData(appId);
                     break;
                 default:
                     throw new Error(`Unknown ConditionType :${item.conditionType}`);
@@ -49,23 +50,32 @@ export class ConditionItemsResultObserver {
     emitConditionResult() {
         let isControl = true;
         const elementStates = [];
+        const formatConditionResults = [];
         this.conditionResults.forEach(t => {
+            formatConditionResults.push({
+                key: t.key,
+                result: t
+            });
             // eslint-disable-next-line eqeqeq
             if (t.relationType == RelationType.None) {
                 isControl = t.result.value;
                 elementStates.push(t.result.state);
             }
         });
-        this.conditionResults.forEach(item => {
+        const formatResults = sortBy(formatConditionResults, data => {
+            return data.key;
+        });
+        formatResults.forEach(item => {
+            const relationCondition = item.result;
             // eslint-disable-next-line eqeqeq
-            if (item.relationType == RelationType.Or) {
-                isControl = isControl || item.result.value;
-                elementStates.push(item.result.state);
+            if (relationCondition.relationType == RelationType.Or) {
+                isControl = isControl || relationCondition.result.value;
+                elementStates.push(relationCondition.result.state);
                 // eslint-disable-next-line eqeqeq
             }
-            else if (item.relationType == RelationType.And) {
-                isControl = isControl && item.result.value;
-                elementStates.push(item.result.state);
+            else if (relationCondition.relationType == RelationType.And) {
+                isControl = isControl && relationCondition.result.value;
+                elementStates.push(relationCondition.result.state);
             }
         });
         const conditionControlResult = {

package/model/shared/condition/condition-items-result-observer.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"ConditionItemsResultObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","name":"Array","arguments":[{"__symbolic":"reference","module":"./condition-item-model","name":"ConditionItemModel","line":19,"character":55}]},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":20,"character":47},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":21,"character":40}]}],"requestData":[{"__symbolic":"method"}],"emitConditionResult":[{"__symbolic":"method"}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"ConditionItemsResultObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","name":"Array","arguments":[{"__symbolic":"reference","module":"./condition-item-model","name":"ConditionItemModel","line":20,"character":55}]},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":21,"character":47},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":22,"character":40}]}],"requestData":[{"__symbolic":"method"}],"emitConditionResult":[{"__symbolic":"method"}]}}}}]

package/model/shared/condition/convert-condition-model.d.ts

@@ -0,0 +1,5 @@
+import { RelationConditionResult } from './relation-condition-result';
+export interface ConvertConditionModel {
+    readonly key: number;
+    readonly result: RelationConditionResult;
+}

package/model/shared/condition/convert-condition-model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConvertConditionModel":{"__symbolic":"interface"}}}]

package/model/shared/condition/relation-condition-result.d.ts

@@ -1,7 +1,8 @@
 import { RelationType } from './relation-type';
 import { RelationConditionResultState } from './relation-condition-result-state';
 export declare class RelationConditionResult {
+    readonly key: number;
     readonly relationType: RelationType;
     readonly result: RelationConditionResultState;
-    constructor(relationType: RelationType, result: RelationConditionResultState);
+    constructor(key: number, relationType: RelationType, result: RelationConditionResultState);
 }

package/model/shared/condition/relation-condition-result.js

@@ -1,5 +1,6 @@
 export class RelationConditionResult {
-    constructor(relationType, result) {
+    constructor(key, relationType, result) {
+        this.key = key;
         this.relationType = relationType;
         this.result = result;
     }

package/model/shared/condition/relation-condition-result.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"RelationConditionResult":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./relation-type","name":"RelationType","line":4,"character":46},{"__symbolic":"reference","module":"./relation-condition-result-state","name":"RelationConditionResultState","line":4,"character":84}]}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"RelationConditionResult":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","name":"number"},{"__symbolic":"reference","module":"./relation-type","name":"RelationType","line":4,"character":75},{"__symbolic":"reference","module":"./relation-condition-result-state","name":"RelationConditionResultState","line":4,"character":113}]}]}}}}]

package/model/shared/condition/word-condition-item-observer.d.ts

@@ -12,7 +12,7 @@ export declare class WordConditionItemObserver extends ConditionItemObserver {
     get baseVariable(): string;
     get realtionVariable(): string;
     constructor(wordCondition: WordConditionModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
-    requestData(): void;
+    requestData(appId: string): void;
     private requestconditionEffectiveValue;
     private requestconditionEffectiveBaseValue;
     private requestconditionEffectiveRealtionValue;

package/model/shared/condition/word-condition-item-observer.js

@@ -28,7 +28,7 @@ export class WordConditionItemObserver extends ConditionItemObserver {
         const variable = new VariableDefinition(variableValue.variableName, variableValue.variableGroupName, variableValue.dataSourceCode, variableValue.variableVersion);
         return VariableUtil.getConvertedVariableName(this.variableStore, variable);
     }
-    requestData() {
+    requestData(appId) {
         if (!this.wordCondition) {
             throw new Error('WordConditionModel cannot be null.');
         }
@@ -43,7 +43,7 @@ export class WordConditionItemObserver extends ConditionItemObserver {
             if (this.variableName) {
                 this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
                     if (variableValue.state === VariableStateEnum.Normal) {
-                        this.requestconditionEffectiveBaseValue(this.variableCommunicator);
+                        this.requestconditionEffectiveBaseValue(this.variableCommunicator, appId);
                     }
                     else {
                         this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
@@ -63,7 +63,7 @@ export class WordConditionItemObserver extends ConditionItemObserver {
                 if (this.variableName) {
                     this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableState => {
                         if (variableState.state === VariableStateEnum.Normal) {
-                            this.requestconditionEffectiveRealtionValue(this.variableCommunicator);
+                            this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
                         }
                         else {
                             this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableState.state), false));
@@ -71,14 +71,14 @@ export class WordConditionItemObserver extends ConditionItemObserver {
                     });
                 }
                 else {
-                    this.requestconditionEffectiveRealtionValue(this.variableCommunicator);
+                    this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
                 }
             }
         }
         if (this.variableName) {
             this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
                 if (variableValue.state === VariableStateEnum.Normal) {
-                    this.requestconditionEffectiveValue(this.variableCommunicator);
+                    this.requestconditionEffectiveValue(this.variableCommunicator, appId);
                 }
                 else {
                     this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
@@ -86,22 +86,22 @@ export class WordConditionItemObserver extends ConditionItemObserver {
             });
         }
     }
-    requestconditionEffectiveValue(variableCommunicator) {
-        variableCommunicator.openVariable(this.variableName).subscribe(variableValue => {
+    requestconditionEffectiveValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.variableName, appId).subscribe(variableValue => {
             this.currentValue = variableValue;
             this.isConditionEffective = this.getIsConditionEffective();
             this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
         });
     }
-    requestconditionEffectiveBaseValue(variableCommunicator) {
-        variableCommunicator.openVariable(this.baseVariable).subscribe(variableValue => {
+    requestconditionEffectiveBaseValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.baseVariable, appId).subscribe(variableValue => {
             this.baseVariableValue = variableValue;
             this.isConditionEffective = this.getIsConditionEffective();
             this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
         });
     }
-    requestconditionEffectiveRealtionValue(variableCommunicator) {
-        variableCommunicator.openVariable(this.realtionVariable).subscribe(variableValue => {
+    requestconditionEffectiveRealtionValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.realtionVariable, appId).subscribe(variableValue => {
             this.realtionVariableValue = variableValue;
             this.isConditionEffective = this.getIsConditionEffective();
             this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));

package/model/shared/dynamic-display/dynamic-display.d.ts

@@ -7,5 +7,5 @@ import { Point } from '../point.model';
 import { VariableStore } from '../../../config';
 export declare class DynamicDisplay implements DynamicDisplayBehaviorModel {
     readonly doBehavior: EventEmitter<DynamicDisplayResultModel>;
-    constructor(dynamicDisplay: DynamicDisplayModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, location: Point);
+    constructor(dynamicDisplay: DynamicDisplayModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, location: Point, signalRAppId: string);
 }

package/model/shared/dynamic-display/dynamic-display.js

@@ -5,11 +5,11 @@ import { TranslationBehavior } from '../translation/translation-behavior';
 import { DynamicDisplayResultModel } from './dynamic-display-result-model';
 import { DynamicBehaviorType } from './dynamic-behavior-type';
 export class DynamicDisplay {
-    constructor(dynamicDisplay, variableCommunicator, variableStore, location) {
+    constructor(dynamicDisplay, variableCommunicator, variableStore, location, signalRAppId) {
         this.doBehavior = new EventEmitter();
         if (dynamicDisplay.isHorizontalTranslation && dynamicDisplay.horizontalTranslation != null) {
             // tslint:disable-next-line:max-line-length
-            const horizontalBehavior = new TranslationBehavior(dynamicDisplay.horizontalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Horizontal, location);
+            const horizontalBehavior = new TranslationBehavior(dynamicDisplay.horizontalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Horizontal, location, signalRAppId);
             horizontalBehavior.doTranslation.subscribe(tanslation => {
                 // tslint:disable-next-line:max-line-length
                 const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.HorizontalTranslation);
@@ -18,14 +18,14 @@ export class DynamicDisplay {
         }
         if (dynamicDisplay.isVerticalTranslation && dynamicDisplay.verticalTranslation != null) {
             // tslint:disable-next-line:max-line-length
-            const verticalBehavior = new TranslationBehavior(dynamicDisplay.verticalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Vertical, location);
+            const verticalBehavior = new TranslationBehavior(dynamicDisplay.verticalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Vertical, location, signalRAppId);
             verticalBehavior.doTranslation.subscribe(tanslation => {
                 const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.VerticalTranslation);
                 this.doBehavior.emit(dynamicDisplayResult);
             });
         }
         if (dynamicDisplay.isRotation && dynamicDisplay.rotation != null) {
-            const rotationBehavior = new RotationBehavior(dynamicDisplay.rotation, variableCommunicator, variableStore);
+            const rotationBehavior = new RotationBehavior(dynamicDisplay.rotation, variableCommunicator, variableStore, signalRAppId);
             rotationBehavior.doRotation.subscribe(angel => {
                 const dynamicDisplayResult = new DynamicDisplayResultModel(undefined, angel, DynamicBehaviorType.Rotation);
                 this.doBehavior.emit(dynamicDisplayResult);

package/model/shared/dynamic-display/dynamic-display.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"DynamicDisplay":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./dynamic-display-model","name":"DynamicDisplayModel","line":18,"character":32},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":18,"character":75},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":18,"character":112},{"__symbolic":"reference","module":"../point.model","name":"Point","line":18,"character":137}]}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"DynamicDisplay":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./dynamic-display-model","name":"DynamicDisplayModel","line":18,"character":32},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":18,"character":75},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":18,"character":112},{"__symbolic":"reference","module":"../point.model","name":"Point","line":19,"character":18},{"__symbolic":"reference","name":"string"}]}]}}}}]

package/model/shared/rotation/rotation-behavior.d.ts

@@ -5,5 +5,5 @@ import { RotationModel } from './rotation-model';
 import { VariableStore } from '../../../config';
 export declare class RotationBehavior implements RotationBehaviorModel {
     readonly doRotation: EventEmitter<number>;
-    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
+    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
 }

package/model/shared/rotation/rotation-behavior.js

@@ -2,9 +2,9 @@ import { EventEmitter } from '@angular/core';
 import { RotationDirectionType } from './rotation-direction-type';
 import { RotationObserver } from './rotation-observer';
 export class RotationBehavior {
-    constructor(rotationModel, variableCommunicator, variableStore) {
+    constructor(rotationModel, variableCommunicator, variableStore, signalRAppId) {
         this.doRotation = new EventEmitter();
-        const rotationObserver = new RotationObserver(rotationModel, variableCommunicator, variableStore);
+        const rotationObserver = new RotationObserver(rotationModel, variableCommunicator, variableStore, signalRAppId);
         rotationObserver.rotationValueChanged.subscribe(rotationValue => {
             if (+rotationModel.rotationDirection === RotationDirectionType.ClockWise) {
                 let newRotation;

package/model/shared/rotation/rotation-behavior.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"RotationBehavior":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./rotation-model","name":"RotationModel","line":13,"character":31},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":13,"character":68},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":13,"character":105}]}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"RotationBehavior":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./rotation-model","name":"RotationModel","line":13,"character":31},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":13,"character":68},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":13,"character":105},{"__symbolic":"reference","name":"string"}]}]}}}}]

package/model/shared/rotation/rotation-observer.d.ts

@@ -4,7 +4,8 @@ import { VariableCommunicator } from '../../../communication';
 import { EventEmitter } from '@angular/core';
 import { VariableStore } from '../../../config';
 export declare class RotationObserver implements RotationObserverModel {
+    private readonly signalRAppId;
     readonly rotationValueChanged: EventEmitter<number>;
     private currentValue;
-    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
+    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
 }

package/model/shared/rotation/rotation-observer.js

@@ -3,7 +3,8 @@ import { EventEmitter } from '@angular/core';
 import { VariableUtil } from '../../../utils/variable-util';
 import { VariableDefinition } from '../../../communication/variable/variable-definition';
 export class RotationObserver {
-    constructor(rotationModel, variableCommunicator, variableStore) {
+    constructor(rotationModel, variableCommunicator, variableStore, signalRAppId) {
+        this.signalRAppId = signalRAppId;
         this.rotationValueChanged = new EventEmitter();
         if (!rotationModel.variableName) {
             return;
@@ -15,7 +16,7 @@ export class RotationObserver {
         }
         variableCommunicator.subscribeVariableState(variableName).subscribe(variableValue => {
             if (variableValue.state === VariableStateEnum.Normal) {
-                variableCommunicator.openVariable(variableName).subscribe(value => {
+                variableCommunicator.openVariable(variableName, this.signalRAppId).subscribe(value => {
                     if (value.state === VariableStateEnum.DataNormal) {
                         this.currentValue = value;
                         this.rotationValueChanged.emit(this.currentValue.value);

package/model/shared/rotation/rotation-observer.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"RotationObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./rotation-model","name":"RotationModel","line":14,"character":31},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":14,"character":68},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":14,"character":105}]}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"RotationObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./rotation-model","name":"RotationModel","line":14,"character":31},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":14,"character":68},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":14,"character":105},{"__symbolic":"reference","name":"string"}]}]}}}}]

package/model/shared/translation/translation-behavior.d.ts

@@ -7,6 +7,6 @@ import { Point } from '../point.model';
 import { VariableStore } from '../../../config';
 export declare class TranslationBehavior implements TranslationBehaviorModel {
     readonly doTranslation: EventEmitter<number>;
-    constructor(translationModel: TranslationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, translationDirection: TranslationDirectionType, location: Point);
+    constructor(translationModel: TranslationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, translationDirection: TranslationDirectionType, location: Point, signalRAppId: string);
     private getTranslationValue;
 }

package/model/shared/translation/translation-behavior.js

@@ -2,17 +2,17 @@ import { EventEmitter } from '@angular/core';
 import { TranslationObserver } from './translation-observer';
 import { TranslationDirectionType } from './translation-direction-type';
 export class TranslationBehavior {
-    constructor(translationModel, variableCommunicator, variableStore, translationDirection, location) {
+    constructor(translationModel, variableCommunicator, variableStore, translationDirection, location, signalRAppId) {
         this.doTranslation = new EventEmitter();
         if (translationDirection === TranslationDirectionType.Horizontal) {
-            const horizontalTranslation = new TranslationObserver(translationModel, variableCommunicator, variableStore);
+            const horizontalTranslation = new TranslationObserver(translationModel, variableCommunicator, variableStore, signalRAppId);
             horizontalTranslation.translationValueChanged.subscribe(inputValue => {
                 const currentLocation = this.getTranslationValue(translationModel, (+inputValue), location.x);
                 this.doTranslation.emit(currentLocation);
             });
         }
         if (translationDirection === TranslationDirectionType.Vertical) {
-            const verticalTranslation = new TranslationObserver(translationModel, variableCommunicator, variableStore);
+            const verticalTranslation = new TranslationObserver(translationModel, variableCommunicator, variableStore, signalRAppId);
             verticalTranslation.translationValueChanged.subscribe(inputValue => {
                 const currentLocation = this.getTranslationValue(translationModel, (+inputValue), location.y);
                 this.doTranslation.emit(currentLocation);

package/model/shared/translation/translation-behavior.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"TranslationBehavior":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./translation-model","name":"TranslationModel","line":13,"character":34},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":14,"character":30},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":15,"character":23},{"__symbolic":"reference","module":"./translation-direction-type","name":"TranslationDirectionType","line":16,"character":30},{"__symbolic":"reference","module":"../point.model","name":"Point","line":17,"character":18}]}],"getTranslationValue":[{"__symbolic":"method"}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"TranslationBehavior":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./translation-model","name":"TranslationModel","line":13,"character":34},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":14,"character":30},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":15,"character":23},{"__symbolic":"reference","module":"./translation-direction-type","name":"TranslationDirectionType","line":16,"character":30},{"__symbolic":"reference","module":"../point.model","name":"Point","line":17,"character":18},{"__symbolic":"reference","name":"string"}]}],"getTranslationValue":[{"__symbolic":"method"}]}}}}]

package/model/shared/translation/translation-observer.d.ts

@@ -6,5 +6,5 @@ import { VariableStore } from '../../../config';
 export declare class TranslationObserver implements TranslationObserverModel {
     readonly translationValueChanged: EventEmitter<number>;
     private currentValue;
-    constructor(model: TranslationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
+    constructor(model: TranslationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
 }

package/model/shared/translation/translation-observer.js

@@ -3,7 +3,7 @@ import { VariableStateEnum } from '../../../communication';
 import { VariableUtil } from '../../../utils/variable-util';
 import { VariableDefinition } from '../../../communication/variable/variable-definition';
 export class TranslationObserver {
-    constructor(model, variableCommunicator, variableStore) {
+    constructor(model, variableCommunicator, variableStore, signalRAppId) {
         this.translationValueChanged = new EventEmitter();
         if (!model.variableName) {
             return;
@@ -15,7 +15,7 @@ export class TranslationObserver {
         }
         variableCommunicator.subscribeVariableState(variableName).subscribe(variableValue => {
             if (variableValue.state === VariableStateEnum.Normal) {
-                variableCommunicator.openVariable(variableName).subscribe(value => {
+                variableCommunicator.openVariable(variableName, signalRAppId).subscribe(value => {
                     if (value.state === VariableStateEnum.DataNormal) {
                         this.currentValue = value;
                         this.translationValueChanged.emit(this.currentValue.value);

package/model/shared/translation/translation-observer.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"TranslationObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./translation-model","name":"TranslationModel","line":15,"character":23},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":15,"character":63},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":15,"character":100}]}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"TranslationObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./translation-model","name":"TranslationModel","line":15,"character":23},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":15,"character":63},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":15,"character":100},{"__symbolic":"reference","name":"string"}]}]}}}}]

package/model/switch-indicator-light/bit-switch-operation.d.ts

@@ -1,5 +1,6 @@
 export declare enum BitSwitchOperation {
     On = 0,
     Off = 1,
-    Inverse = 2
+    Inverse = 2,
+    Restoration = 3
 }

package/model/switch-indicator-light/bit-switch-operation.js

@@ -3,4 +3,5 @@ export var BitSwitchOperation;
     BitSwitchOperation[BitSwitchOperation["On"] = 0] = "On";
     BitSwitchOperation[BitSwitchOperation["Off"] = 1] = "Off";
     BitSwitchOperation[BitSwitchOperation["Inverse"] = 2] = "Inverse";
+    BitSwitchOperation[BitSwitchOperation["Restoration"] = 3] = "Restoration";
 })(BitSwitchOperation || (BitSwitchOperation = {}));

package/model/switch-indicator-light/bit-switch-operation.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"BitSwitchOperation":{"On":0,"Off":1,"Inverse":2}}}]
+[{"__symbolic":"module","version":4,"metadata":{"BitSwitchOperation":{"On":0,"Off":1,"Inverse":2,"Restoration":3}}}]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"main": "bundles/fc-gui.umd.js",
-	"version": "3.0.0-alpha.3",
+	"version": "3.0.0-alpha.32",
 	"module": "public_api.js",
 	"typings": "public_api.d.ts",
 	"license": "UNLICENSED",

package/remote/communication/variable/remote-variable-communicator.d.ts

@@ -6,6 +6,7 @@ export declare class RemoteVariableCommunicator implements VariableCommunicator
     private readonly remoteVariableProtocol;
     private readonly logger;
     private observers;
+    private appIdVariablesMap;
     private connectedSubscription;
     private variableValuesChangedSubscription;
     private variablesToBeOpened;
@@ -21,8 +22,8 @@ export declare class RemoteVariableCommunicator implements VariableCommunicator
     private doVariableStatesChanged;
     subscribeVariableStates(variableNames: string[]): Observable<VariableState[]>;
     subscribeVariableState(variableName: string): Observable<VariableState>;
-    openVariables(variableNames: string[]): Observable<VariableValue[]>;
-    openVariable(variableName: string): Observable<VariableValue>;
+    openVariables(variableNames: string[], appId?: string): Observable<VariableValue[]>;
+    openVariable(variableName: string, appId?: string): Observable<VariableValue>;
     write(variableName: string, value: any): Observable<VariableValue>;
     writeWordByBit(variableName: string, index: number, value: number): Observable<VariableValue>;
     dispose(): void;

package/remote/communication/variable/remote-variable-communicator.js

@@ -7,6 +7,7 @@ export class RemoteVariableCommunicator {
         this.remoteVariableProtocol = remoteVariableProtocol;
         this.logger = logger;
         this.observers = new Map();
+        this.appIdVariablesMap = new Map();
         this.variableStateObservers = new Map();
         this.variableStateCache = new Map();
         this.variableValueCache = new StringifyingMap(k => JSON.stringify(k));
@@ -16,11 +17,9 @@ export class RemoteVariableCommunicator {
                 variableNamesToStart.push(variableName);
             });
             this.remoteVariableProtocol.subscribeVariableStates(variableNamesToStart);
-            const variablesToStart = [];
-            this.observers.forEach((__, variableName) => {
-                variablesToStart.push(variableName);
+            this.appIdVariablesMap.forEach((variableNames, appId) => {
+                this.remoteVariableProtocol.tryOpenVariables(variableNames, appId);
             });
-            this.remoteVariableProtocol.tryOpenVariables(variablesToStart);
         });
         this.doVariableStatesChanged();
         this.doVariableValuesChanged();
@@ -116,7 +115,7 @@ export class RemoteVariableCommunicator {
     subscribeVariableState(variableName) {
         return this.subscribeVariableStates([variableName]).pipe(map(values => values[0]));
     }
-    openVariables(variableNames) {
+    openVariables(variableNames, appId = '') {
         return new Observable(observer => {
             let variablesToStart = [];
             each(variableNames, variableName => {
@@ -131,6 +130,14 @@ export class RemoteVariableCommunicator {
                         }
                     }
                     this.observers.get(variableName).push(observer);
+                    if (!this.appIdVariablesMap.get(appId)) {
+                        this.appIdVariablesMap.set(appId, []);
+                    }
+                    else {
+                        if (this.appIdVariablesMap.get(appId).indexOf(variableName) === -1) {
+                            this.appIdVariablesMap.get(appId).push(variableName);
+                        }
+                    }
                 }
             });
             variablesToStart = uniq(variablesToStart);
@@ -138,7 +145,7 @@ export class RemoteVariableCommunicator {
                 if (!this.variablesToBeOpened) {
                     this.variablesToBeOpened = [];
                     setTimeout(() => {
-                        this.remoteVariableProtocol.tryOpenVariables(this.variablesToBeOpened);
+                        this.remoteVariableProtocol.tryOpenVariables(this.variablesToBeOpened, appId);
                         delete this.variablesToBeOpened;
                     });
                 }
@@ -162,7 +169,7 @@ export class RemoteVariableCommunicator {
                 if (!this.variablesToBeClosed) {
                     this.variablesToBeClosed = [];
                     setTimeout(() => {
-                        this.remoteVariableProtocol.tryStopVariables(this.variablesToBeClosed);
+                        this.remoteVariableProtocol.tryStopVariables(this.variablesToBeClosed, appId);
                         delete this.variablesToBeClosed;
                     });
                 }
@@ -170,11 +177,11 @@ export class RemoteVariableCommunicator {
             };
         });
     }
-    openVariable(variableName) {
+    openVariable(variableName, appId = '') {
         if (!variableName) {
             return;
         }
-        return this.openVariables([variableName]).pipe(map(values => values[0]));
+        return this.openVariables([variableName], appId).pipe(map(values => values[0]));
     }
     write(variableName, value) {
         if (!variableName) {