@magic-xpa/engine 4.801.0-dev481.306 → 4.801.0-dev481.309

package/fesm2015/magic-xpa-engine.mjs

@@ -1,7 +1,7 @@
 import { __awaiter } from 'tslib';
-import { StringBuilder, Int32, NString, ApplicationException, NNumber, List, Debug, Char, RefParam, NumberStyles, Exception, HashUtils, DateTime, Dictionary, Stack, NChar, isNullOrUndefined, WebException, Thread, Encoding, isUndefined, Hashtable, NotImplementedException, Array_Enumerator, ISO_8859_1_Encoding, Int64 } from '@magic-xpa/mscorelib';
-import { XMLConstants, StorageAttribute, ViewRefreshMode, InternalInterface, Logger, StorageAttributeCheck, StrUtil, SubformType, TableBehaviour, MgControlType, ScrollBarThumbType, ForceExit, XmlParser, Misc, Base64, Priority, SyncExecutionHelper, Queue, Constants, DateTimeUtils, Logger_LogLevels, Logger_MessageDirection, MsgInterface, RequestInfo, OSEnvironment, JSON_Utils, UtilDateJpn, UtilStrByteMode, CallOsShow, PICInterface, WindowType, BrkScope, RaiseAt, CtrlButtonTypeGui } from '@magic-xpa/utils';
-import { RecordUtils, GuiFieldBase, ExpVal, BlobType, FieldDef, GuiTaskBase, ControlTable, MgControlBase, PropInterface, GuiDataCollection, CommandType, Commands, HtmlProperties, Modifiers, KeyboardItem, TaskDefinitionIdTableSaxHandler, DisplayConvertor, PIC, MgTimer, GuiConstants, RuntimeContextBase, UsernamePasswordCredentials, Styles, Manager, NUM_TYPE, VectorType, GuiExpressionEvaluator, ExpressionInterface, DataModificationTypes, GuiDataViewBase, ObjectReferencesCollection, EMPTY_DCREF, ObjectReferenceBase, PropTable, FieldsTable as FieldsTable$1, DcValuesBuilderBase, MgFormBase, GuiEnvironment, TaskDefinitionId, Events, Helps, FocusManager, EventsProcessor, UIBridge } from '@magic-xpa/gui';
+import { StringBuilder, Int32, NString, ApplicationException, NNumber, List, Debug, Char, RefParam, NumberStyles, HashUtils, DateTime, Dictionary, Stack, NChar, isNullOrUndefined, WebException, Thread, Encoding, Exception, isUndefined, Hashtable, NotImplementedException, Array_Enumerator, ISO_8859_1_Encoding, Int64 } from '@magic-xpa/mscorelib';
+import { XMLConstants, StorageAttribute, ViewRefreshMode, InternalInterface, Logger, StorageAttributeCheck, StrUtil, SubformType, TableBehaviour, MgControlType, ScrollBarThumbType, ForceExit, XmlParser, Misc, Base64, Priority, SyncExecutionHelper, Queue, Constants, DateTimeUtils, Logger_LogLevels, Logger_MessageDirection, MsgInterface, RequestInfo, OSEnvironment, JSON_Utils, UtilDateJpn, UtilStrByteMode, PICInterface, WindowType, BrkScope, RaiseAt, CtrlButtonTypeGui } from '@magic-xpa/utils';
+import { RecordUtils, GuiFieldBase, ExpVal, BlobType, FieldDef, GuiTaskBase, MgControlBase, PropInterface, GuiDataCollection, CommandType, Commands, HtmlProperties, ControlTable, Modifiers, KeyboardItem, TaskDefinitionIdTableSaxHandler, DisplayConvertor, MgTimer, GuiConstants, RuntimeContextBase, UsernamePasswordCredentials, Styles, Manager, NUM_TYPE, VectorType, GuiExpressionEvaluator, ExpressionInterface, PIC, DataModificationTypes, GuiDataViewBase, ObjectReferencesCollection, EMPTY_DCREF, ObjectReferenceBase, PropTable, FieldsTable as FieldsTable$1, DcValuesBuilderBase, MgFormBase, GuiEnvironment, TaskDefinitionId, Events, Helps, FocusManager, EventsProcessor, UIBridge } from '@magic-xpa/gui';
 import { HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import { timer, Subject } from 'rxjs';
 
@@ -1424,157 +1424,6 @@ class OpeningTaskDetails {
     }
 }
 
-class TasksTable {
-    constructor() {
-        this._tasks = null;
-        this._tasks = new List();
-    }
-    fillData(mgdata, openingTaskDetails, parser) {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (yield this.initInnerObjects(parser.getNextTag(), mgdata, openingTaskDetails)) {
-            }
-        });
-    }
-    initInnerObjects(foundTagName, mgdata, openingTaskDetails) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result;
-            if (foundTagName === null) {
-                result = false;
-            }
-            else {
-                if (foundTagName === XMLConstants.MG_TAG_TASK) {
-                    let task = TasksTable.createNewtask();
-                    this._tasks.push(task);
-                    yield task.fillData(mgdata, openingTaskDetails);
-                    result = true;
-                }
-                else {
-                    result = false;
-                }
-            }
-            return result;
-        });
-    }
-    addTask(task) {
-        this._tasks.push(task);
-    }
-    removeTask(task) {
-        this._tasks.Remove(task);
-    }
-    getTask(tasktagOrIdx) {
-        if (arguments.length === 1 && (tasktagOrIdx === null || typeof tasktagOrIdx === "undefined" || tasktagOrIdx.constructor === String)) {
-            return this.getTask_0(tasktagOrIdx);
-        }
-        return this.getTask_1(tasktagOrIdx);
-    }
-    getTask_0(tasktag) {
-        let result;
-        for (let i = 0; i < this._tasks.length; i = i + 1) {
-            let task = this._tasks.get_Item(i);
-            if (tasktag === task.getTaskTag()) {
-                result = task;
-                return result;
-            }
-        }
-        result = null;
-        return result;
-    }
-    getTask_1(idx) {
-        let result;
-        if (idx >= 0 && idx < this._tasks.length) {
-            result = this._tasks.get_Item(idx);
-        }
-        else {
-            result = null;
-        }
-        return result;
-    }
-    getSize() {
-        return this._tasks.length;
-    }
-    buildXML(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let i = 0; i < this.getSize(); i = i + 1) {
-                yield this.getTask(i).buildXML(message);
-            }
-        });
-    }
-    setTaskAt(task, index) {
-        if (this._tasks.length <= index) {
-            this._tasks.SetSize(index + 1);
-        }
-        this._tasks.set_Item(index, task);
-    }
-}
-TasksTable.createNewtask = null;
-
-class LastFocusedManager {
-    constructor() {
-        this._lastFocusedTasks = null;
-        this.LastActionTime = 0;
-    }
-    Init(mgDataTable) {
-        this._lastFocusedTasks = new TasksTable();
-    }
-    getCurrTask() {
-        let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();
-        return (rtEvnt !== null && rtEvnt.getTask() !== null && rtEvnt.getTask().GetContextTask() !== null)
-            ? this.getLastFocusedTask(rtEvnt.getTask().GetContextTask().getMgdID())
-            : this.getLastFocusedTask();
-    }
-    getLastFocusedTask(mgdID) {
-        if (arguments.length === 0)
-            return this._lastFocusedTasks.getTask(AccessHelper.mgDataTable.currMgdID);
-        else
-            return this._lastFocusedTasks.getTask(mgdID);
-    }
-    setLastFocusedTask(iTask) {
-        let currFocusedTask = this.getLastFocusedTask();
-        if (currFocusedTask !== null && currFocusedTask !== iTask) {
-            let oldForm = currFocusedTask.getForm();
-        }
-        let task = iTask;
-        let currMgdID = task.getMgdID();
-        this._lastFocusedTasks.setTaskAt(task, currMgdID);
-    }
-    clean(index) {
-        LastFocusedManager.deleteLastFocusedControlAt(index);
-        if (this._lastFocusedTasks !== null) {
-            this._lastFocusedTasks.setTaskAt(null, index);
-        }
-    }
-    static getLastFocusedControl(mgdID) {
-        if (arguments.length === 1)
-            return LastFocusedManager.getLastFocusedControl_1(mgdID);
-        else
-            return LastFocusedManager.getLastFocusedControl_0();
-    }
-    static getLastFocusedControl_0() {
-        return LastFocusedManager._lastFocusedControls.getCtrl(AccessHelper.mgDataTable.currMgdID);
-    }
-    static getLastFocusedControl_1(mgdID) {
-        return LastFocusedManager._lastFocusedControls.getCtrl(mgdID);
-    }
-    static deleteLastFocusedControlAt(index) {
-        if (LastFocusedManager._lastFocusedControls !== null && LastFocusedManager._lastFocusedControls.getCtrl(index) != null) {
-            LastFocusedManager._lastFocusedControls.deleteControlAt(index);
-        }
-    }
-    static setLastFocusedControlAt(ctrl, currMgdID) {
-        LastFocusedManager._lastFocusedControls.setControlAt(ctrl, currMgdID);
-    }
-    static setLastFocusedControl(task, mgControl) {
-        let currMgdID = task.getMgdID();
-        Debug.Assert(mgControl === null || task === mgControl.getForm().getTask());
-        LastFocusedManager.LastFocusMgdID = currMgdID;
-        LastFocusedManager.setLastFocusedControlAt(mgControl, currMgdID);
-        LastFocusedManager.Instance.setLastFocusedTask(task);
-    }
-}
-LastFocusedManager.Instance = new LastFocusedManager();
-LastFocusedManager._lastFocusedControls = new ControlTable();
-LastFocusedManager.LastFocusMgdID = 0;
-
 class MgControl extends MgControlBase {
     constructor(type, taskOrParentMgForm, parentControlOrParentControlIdx) {
         if (arguments.length === 0)
@@ -1922,12 +1771,10 @@ class MgControl extends MgControlBase {
     }
     refreshAndSetItemsListForRadioButton(line, execComputeChoice) {
         const _super = Object.create(null, {
-            refreshAndSetItemsListForRadioButton: { get: () => super.refreshAndSetItemsListForRadioButton },
-            getForm: { get: () => super.getForm }
+            refreshAndSetItemsListForRadioButton: { get: () => super.refreshAndSetItemsListForRadioButton }
         });
         return __awaiter(this, void 0, void 0, function* () {
             yield _super.refreshAndSetItemsListForRadioButton.call(this, line, execComputeChoice);
-            let lastFocusedTask = LastFocusedManager.Instance.getLastFocusedTask(_super.getForm.call(this).getTask().getMgdID());
         });
     }
     getSubformTask() {
@@ -2056,14 +1903,158 @@ class MgPriorityQueue {
 }
 MgPriorityQueue.DEFAULT_INITIAL_CAPACITY = 11;
 
+class TasksTable {
+    constructor() {
+        this._tasks = null;
+        this._tasks = new List();
+    }
+    fillData(mgdata, openingTaskDetails, parser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (yield this.initInnerObjects(parser.getNextTag(), mgdata, openingTaskDetails)) {
+            }
+        });
+    }
+    initInnerObjects(foundTagName, mgdata, openingTaskDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result;
+            if (foundTagName === null) {
+                result = false;
+            }
+            else {
+                if (foundTagName === XMLConstants.MG_TAG_TASK) {
+                    let task = TasksTable.createNewtask();
+                    this._tasks.push(task);
+                    yield task.fillData(mgdata, openingTaskDetails);
+                    result = true;
+                }
+                else {
+                    result = false;
+                }
+            }
+            return result;
+        });
+    }
+    addTask(task) {
+        this._tasks.push(task);
+    }
+    removeTask(task) {
+        this._tasks.Remove(task);
+    }
+    getTask(tasktagOrIdx) {
+        if (arguments.length === 1 && (tasktagOrIdx === null || typeof tasktagOrIdx === "undefined" || tasktagOrIdx.constructor === String)) {
+            return this.getTask_0(tasktagOrIdx);
+        }
+        return this.getTask_1(tasktagOrIdx);
+    }
+    getTask_0(tasktag) {
+        let result;
+        for (let i = 0; i < this._tasks.length; i = i + 1) {
+            let task = this._tasks.get_Item(i);
+            if (tasktag === task.getTaskTag()) {
+                result = task;
+                return result;
+            }
+        }
+        result = null;
+        return result;
+    }
+    getTask_1(idx) {
+        let result;
+        if (idx >= 0 && idx < this._tasks.length) {
+            result = this._tasks.get_Item(idx);
+        }
+        else {
+            result = null;
+        }
+        return result;
+    }
+    getSize() {
+        return this._tasks.length;
+    }
+    buildXML(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < this.getSize(); i = i + 1) {
+                yield this.getTask(i).buildXML(message);
+            }
+        });
+    }
+    setTaskAt(task, index) {
+        if (this._tasks.length <= index) {
+            this._tasks.SetSize(index + 1);
+        }
+        this._tasks.set_Item(index, task);
+    }
+}
+TasksTable.createNewtask = null;
+
+class LastFocusedManager {
+    constructor() {
+        this._lastFocusedTasks = null;
+        this.LastActionTime = 0;
+    }
+    Init(mgDataTable) {
+        this._lastFocusedTasks = new TasksTable();
+    }
+    getCurrTask() {
+        let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();
+        return (rtEvnt !== null && rtEvnt.getTask() !== null && rtEvnt.getTask().GetContextTask() !== null)
+            ? this.getLastFocusedTask(rtEvnt.getTask().GetContextTask().getMgdID())
+            : this.getLastFocusedTask();
+    }
+    getLastFocusedTask(mgdID) {
+        if (arguments.length === 0)
+            return this._lastFocusedTasks.getTask(AccessHelper.mgDataTable.currMgdID);
+        else
+            return this._lastFocusedTasks.getTask(mgdID);
+    }
+    setLastFocusedTask(iTask) {
+        let task = iTask;
+        let currMgdID = task.getMgdID();
+        this._lastFocusedTasks.setTaskAt(task, currMgdID);
+    }
+    clean(index) {
+        LastFocusedManager.deleteLastFocusedControlAt(index);
+        if (this._lastFocusedTasks !== null) {
+            this._lastFocusedTasks.setTaskAt(null, index);
+        }
+    }
+    static getLastFocusedControl(mgdID) {
+        if (arguments.length === 1)
+            return LastFocusedManager.getLastFocusedControl_1(mgdID);
+        else
+            return LastFocusedManager.getLastFocusedControl_0();
+    }
+    static getLastFocusedControl_0() {
+        return LastFocusedManager._lastFocusedControls.getCtrl(AccessHelper.mgDataTable.currMgdID);
+    }
+    static getLastFocusedControl_1(mgdID) {
+        return LastFocusedManager._lastFocusedControls.getCtrl(mgdID);
+    }
+    static deleteLastFocusedControlAt(index) {
+        if (LastFocusedManager._lastFocusedControls !== null && LastFocusedManager._lastFocusedControls.getCtrl(index) != null) {
+            LastFocusedManager._lastFocusedControls.deleteControlAt(index);
+        }
+    }
+    static setLastFocusedControlAt(ctrl, currMgdID) {
+        LastFocusedManager._lastFocusedControls.setControlAt(ctrl, currMgdID);
+    }
+    static setLastFocusedControl(task, mgControl) {
+        let currMgdID = task.getMgdID();
+        Debug.Assert(mgControl === null || task === mgControl.getForm().getTask());
+        LastFocusedManager.LastFocusMgdID = currMgdID;
+        LastFocusedManager.setLastFocusedControlAt(mgControl, currMgdID);
+        LastFocusedManager.Instance.setLastFocusedTask(task);
+    }
+}
+LastFocusedManager.Instance = new LastFocusedManager();
+LastFocusedManager._lastFocusedControls = new ControlTable();
+LastFocusedManager.LastFocusMgdID = 0;
+
 class Event {
     constructor() {
         this.Exp = null;
         this._forceExit = ForceExit.None;
         this.kbdItm = null;
-        this._osCommandShow = 0;
-        this._osCommandText = null;
-        this._osCommandWait = false;
         this._paramAttrs = null;
         this._paramNulls = null;
         this._paramVals = null;
@@ -2074,11 +2065,9 @@ class Event {
         this._type = Char.MinValue;
         this._userDefinedFuncName = null;
         this._userDefinedFuncNameHashCode = 0;
-        this._userEvtDesc = "";
+        this._userEvtDesc = '';
         this._userEvtIdx = Int32.MinValue;
-        this.ownerTaskDefinitionId = null;
         this.InternalEvent = 0;
-        this.PrgDescription = null;
         this.PublicName = null;
         this.UserEvt = null;
         this.UserEvtTaskTag = null;
@@ -2119,7 +2108,7 @@ class Event {
                 this.InitUserData(taskRef, userValue);
         }
         else
-            Logger.Instance.WriteExceptionToLogWithMsg("in Event.FillData() out of string bounds");
+            Logger.Instance.WriteExceptionToLogWithMsg('in Event.FillData() out of string bounds');
     }
     InitInnerObjects(xmlParser) {
         let nextTag = xmlParser.getNextTag();
@@ -2195,7 +2184,7 @@ class Event {
                 case ConstInterface.MG_TAG_USR_DEF_FUC_RET_EXP_ATTR:
                     break;
                 default:
-                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("There is no such tag in Event class. Insert case to Event.initElements for {0}", attribute));
+                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format('There is no such tag in Event class. Insert case to Event.initElements for {0}', attribute));
                     break;
             }
         }
@@ -2203,7 +2192,7 @@ class Event {
             this.kbdItm = new KeyboardItem(keyCode, modifier);
     }
     InitUserData(taskRef, userValue) {
-        let comma = userValue.indexOf(",");
+        let comma = userValue.indexOf(',');
         if (comma > -1) {
             let ueTaskId = userValue.substr(0, comma);
             if (taskRef !== null)
@@ -2213,8 +2202,8 @@ class Event {
             if (ueTask !== null) {
                 this.UserEvt = ueTask.getUserEvent(ueIdx);
                 if (this.UserEvt === null) {
-                    throw new ApplicationException("in Event.fillData(): user event not found. task id = " + ueTaskId +
-                        ", user event index = " + ueIdx);
+                    throw new ApplicationException('in Event.fillData(): user event not found. task id = ' + ueTaskId +
+                        ', user event index = ' + ueIdx);
                 }
                 this.UserEvtTaskTag = ueTaskId;
                 this._userEvtIdx = ueIdx;
@@ -2231,7 +2220,6 @@ class Event {
         handler.parse(xmlBuffer);
     }
     SetTaskDefinitionId(taskDefinitionId) {
-        this.ownerTaskDefinitionId = taskDefinitionId;
     }
     findUserEvent() {
         if (this._type === ConstInterface.EVENT_TYPE_USER && this.UserEvt === null) {
@@ -2239,7 +2227,7 @@ class Event {
             if (ueTask !== null)
                 this.UserEvt = ueTask.getUserEvent(this._userEvtIdx);
             if (this.UserEvt === null)
-                throw new ApplicationException(NString.Format("in Event.findUserEvent(): user event not found. task id = {0} doesn't exist", this.UserEvtTaskTag));
+                throw new ApplicationException(NString.Format('in Event.findUserEvent(): user event not found. task id = {0} doesn\'t exist', this.UserEvtTaskTag));
         }
     }
     equals(evt) {
@@ -2377,7 +2365,7 @@ class Event {
         return this.getBrkLevel(false);
     }
     getBrkLevel_1(flowMonitor) {
-        let level = "";
+        let level = '';
         switch (this._type) {
             case ConstInterface.EVENT_TYPE_INTERNAL:
                 switch (this.InternalEvent) {
@@ -2422,7 +2410,7 @@ class Event {
                 level = flowMonitor ? ConstInterface.BRK_LEVEL_HANDLER_EXPRESSION_FM : ConstInterface.BRK_LEVEL_HANDLER_EXPRESSION + '_' + this.Exp.getId();
                 break;
             case ConstInterface.EVENT_TYPE_USER:
-                level = (flowMonitor ? (ConstInterface.BRK_LEVEL_HANDLER_USER_FM + ": ") : (ConstInterface.BRK_LEVEL_HANDLER_USER + '_')) + (this.UserEvt != null ? this.UserEvt._userEvtDesc : this._userEvtDesc);
+                level = (flowMonitor ? (ConstInterface.BRK_LEVEL_HANDLER_USER_FM + ': ') : (ConstInterface.BRK_LEVEL_HANDLER_USER + '_')) + (this.UserEvt != null ? this.UserEvt._userEvtDesc : this._userEvtDesc);
                 break;
             case ConstInterface.EVENT_TYPE_USER_FUNC:
                 level = (flowMonitor ? (ConstInterface.BRK_LEVEL_USER_FUNCTION_FM + ':') : (ConstInterface.BRK_LEVEL_USER_FUNCTION + '_')) + this._userDefinedFuncName;
@@ -2434,580 +2422,580 @@ class Event {
         let description;
         switch (internalEventCode) {
             case InternalInterface.MG_ACT_ABOUT:
-                description = "About Magic";
+                description = 'About Magic';
                 break;
             case InternalInterface.MG_ACT_ACTION_LIST:
-                description = "Action List";
+                description = 'Action List';
                 break;
             case InternalInterface.MG_ACT_ADD_HYPERLINK:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_ALIGN_LEFT:
-                description = "Left";
+                description = 'Left';
                 break;
             case InternalInterface.MG_ACT_ALIGN_RIGHT:
-                description = "Right";
+                description = 'Right';
                 break;
             case InternalInterface.MG_ACT_APPL_PROPERTIES:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_APPLICATIONS:
-                description = "Applications";
+                description = 'Applications';
                 break;
             case InternalInterface.MG_ACT_APPLICATIONS_LIST:
-                description = "Applications List";
+                description = 'Applications List';
                 break;
             case InternalInterface.MG_ACT_ATTACH_TO_TABLE:
-                description = "Attach to Table";
+                description = 'Attach to Table';
                 break;
             case InternalInterface.MG_ACT_AUTHORIZE:
-                description = "Authorize";
+                description = 'Authorize';
                 break;
             case InternalInterface.MG_ACT_EDT_BEGFLD:
-                description = "Begin Field";
+                description = 'Begin Field';
                 break;
             case InternalInterface.MG_ACT_EDT_BEGFORM:
-                description = "Begin Form";
+                description = 'Begin Form';
                 break;
             case InternalInterface.MG_ACT_EDT_BEGLINE:
-                description = "Begin Line";
+                description = 'Begin Line';
                 break;
             case InternalInterface.MG_ACT_EDT_BEGNXTLINE:
-                description = "Begin Next Line";
+                description = 'Begin Next Line';
                 break;
             case InternalInterface.MG_ACT_EDT_BEGPAGE:
-                description = "Begin Page";
+                description = 'Begin Page';
                 break;
             case InternalInterface.MG_ACT_TBL_BEGLINE:
-                description = "Begin Row";
+                description = 'Begin Row';
                 break;
             case InternalInterface.MG_ACT_TBL_BEGPAGE:
-                description = "Begin Screen";
+                description = 'Begin Screen';
                 break;
             case InternalInterface.MG_ACT_TBL_BEGTBL:
-                description = "Begin table";
+                description = 'Begin table';
                 break;
             case InternalInterface.MG_ACT_BOTTOM:
-                description = "Bottom";
+                description = 'Bottom';
                 break;
             case InternalInterface.MG_ACT_BULLET:
-                description = "Bullet";
+                description = 'Bullet';
                 break;
             case InternalInterface.MG_ACT_BUTTON:
-                description = "Button Press";
+                description = 'Button Press';
                 break;
             case InternalInterface.MG_ACT_CANCEL:
-                description = "Cancel";
+                description = 'Cancel';
                 break;
             case InternalInterface.MG_ACT_RT_QUIT:
-                description = "Quit";
+                description = 'Quit';
                 break;
             case InternalInterface.MG_ACT_CENTER:
-                description = "Center";
+                description = 'Center';
                 break;
             case InternalInterface.MG_ACT_CHECK_SYNTAX:
-                description = "Check Syntax";
+                description = 'Check Syntax';
                 break;
             case InternalInterface.MG_ACT_CHECK_TO_END:
-                description = "Check to End";
+                description = 'Check to End';
                 break;
             case InternalInterface.MG_ACT_CLEAR_TEMPLATE:
-                description = "Clear Template";
+                description = 'Clear Template';
                 break;
             case InternalInterface.MG_ACT_CLEAR_VALUE:
-                description = "Clear Value";
+                description = 'Clear Value';
                 break;
             case InternalInterface.MG_ACT_CLOSE:
-                description = "Close";
+                description = 'Close';
                 break;
             case InternalInterface.MG_ACT_ACT_CLOSE_APPL:
-                description = "Close Application";
+                description = 'Close Application';
                 break;
             case InternalInterface.MG_ACT_COMMUNICATIONS:
-                description = "Communications";
+                description = 'Communications';
                 break;
             case InternalInterface.MG_ACT_COMPONENTS:
-                description = "Components";
+                description = 'Components';
                 break;
             case InternalInterface.MG_ACT_CTRL_HIT:
-                description = "Control Hit";
+                description = 'Control Hit';
                 break;
             case InternalInterface.MG_ACT_CONTROL_NAME_LIST:
-                description = "Control Name List";
+                description = 'Control Name List';
                 break;
             case InternalInterface.MG_ACT_CLIP_COPY:
-                description = "Copy";
+                description = 'Copy';
                 break;
             case InternalInterface.MG_ACT_COPY_LAYOUT:
-                description = "Copy Layout";
+                description = 'Copy Layout';
                 break;
             case InternalInterface.MG_ACT_COPY_SUBTREE:
-                description = "Copy Subtree";
+                description = 'Copy Subtree';
                 break;
             case InternalInterface.MG_ACT_CRELINE:
-                description = "Create Line";
+                description = 'Create Line';
                 break;
             case InternalInterface.MG_ACT_CRELINE_ABOVE:
-                description = "Create Line Above";
+                description = 'Create Line Above';
                 break;
             case InternalInterface.MG_ACT_CREATE_PARENT:
-                description = "Create Parent";
+                description = 'Create Parent';
                 break;
             case InternalInterface.MG_ACT_RTO_CREATE:
-                description = "Create Records";
+                description = 'Create Records';
                 break;
             case InternalInterface.MG_ACT_CREATE_SUBTASK:
-                description = "Create Subtask";
+                description = 'Create Subtask';
                 break;
             case InternalInterface.MG_ACT_CROSS_REFERENCE:
-                description = "Cross Reference";
+                description = 'Cross Reference';
                 break;
             case InternalInterface.MG_ACT_CUT:
-                description = "Cut";
+                description = 'Cut';
                 break;
             case InternalInterface.MG_ACT_DB_TABLES:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_DBMS:
-                description = "DBMS";
+                description = 'DBMS';
                 break;
             case InternalInterface.MG_ACT_DDF_MAKE:
-                description = "DDF Make";
+                description = 'DDF Make';
                 break;
             case InternalInterface.MG_ACT_DATABASES:
-                description = "Databases";
+                description = 'Databases';
                 break;
             case InternalInterface.MG_ACT_DEFAULT_LAYOUT:
-                description = "Default Layout";
+                description = 'Default Layout';
                 break;
             case InternalInterface.MG_ACT_DEFINE_EXPRESSION:
-                description = "Define Expression";
+                description = 'Define Expression';
                 break;
             case InternalInterface.MG_ACT_EDT_DELCURCH:
-                description = "Current Char";
+                description = 'Current Char';
                 break;
             case InternalInterface.MG_ACT_EDT_DELPRVCH:
-                description = "Previous Char";
+                description = 'Previous Char';
                 break;
             case InternalInterface.MG_ACT_DELETE_HYPERLINK:
-                description = "Delete Hyperlink";
+                description = 'Delete Hyperlink';
                 break;
             case InternalInterface.MG_ACT_DELLINE:
-                description = "Delete Line";
+                description = 'Delete Line';
                 break;
             case InternalInterface.MG_ACT_DELETE_SUBTREE:
-                description = "Delete Subtree";
+                description = 'Delete Subtree';
                 break;
             case InternalInterface.MG_ACT_RT_COPYFLD:
-                description = "Ditto";
+                description = 'Ditto';
                 break;
             case InternalInterface.MG_ACT_DISPLAY_REFRESH:
-                description = "Display Refresh";
+                description = 'Display Refresh';
                 break;
             case InternalInterface.MG_ACT_EDIT_MAIN_FORM:
-                description = "Edit Main Form";
+                description = 'Edit Main Form';
                 break;
             case InternalInterface.MG_ACT_EDT_ENDFLD:
-                description = "End Field";
+                description = 'End Field';
                 break;
             case InternalInterface.MG_ACT_EDT_ENDFORM:
-                description = "End Form";
+                description = 'End Form';
                 break;
             case InternalInterface.MG_ACT_EDT_ENDLINE:
-                description = "End Line";
+                description = 'End Line';
                 break;
             case InternalInterface.MG_ACT_EDT_ENDPAGE:
-                description = "End Page";
+                description = 'End Page';
                 break;
             case InternalInterface.MG_ACT_TBL_ENDLINE:
-                description = "End Row";
+                description = 'End Row';
                 break;
             case InternalInterface.MG_ACT_TBL_ENDPAGE:
-                description = "End Screen";
+                description = 'End Screen';
                 break;
             case InternalInterface.MG_ACT_TBL_ENDTBL:
-                description = "End Table";
+                description = 'End Table';
                 break;
             case InternalInterface.MG_ACT_ENVIRONMENT:
-                description = "Environment";
+                description = 'Environment';
                 break;
             case InternalInterface.MG_ACT_EXECUTE_PROGRAM:
-                description = "Execute Program";
+                description = 'Execute Program';
                 break;
             case InternalInterface.MG_ACT_EXECUTE_REPORT:
-                description = "Execute Report";
+                description = 'Execute Report';
                 break;
             case InternalInterface.MG_ACT_EXIT:
-                description = "Exit";
+                description = 'Exit';
                 break;
             case InternalInterface.MG_ACT_EXIT_SYSTEM:
-                description = "Exit System";
+                description = 'Exit System';
                 break;
             case InternalInterface.MG_ACT_EXPORT_IMPORT:
-                description = "Export/Import";
+                description = 'Export/Import';
                 break;
             case InternalInterface.MG_ACT_EXPRESSION_RULES:
-                description = "Expression rules";
+                description = 'Expression rules';
                 break;
             case InternalInterface.MG_ACT_EXTERNAL_EDITOR:
-                description = "External Editor";
+                description = 'External Editor';
                 break;
             case InternalInterface.MG_ACT_EXT_EVENT:
-                description = "External Event";
+                description = 'External Event';
                 break;
             case InternalInterface.MG_ACT_FORMS:
-                description = "Forms";
+                description = 'Forms';
                 break;
             case InternalInterface.MG_ACT_FROM_VALUE:
-                description = "From Value";
+                description = 'From Value';
                 break;
             case InternalInterface.MG_ACT_FUNCTION_LIST:
-                description = "Function List";
+                description = 'Function List';
                 break;
             case InternalInterface.MG_ACT_GENERATE_FORM:
-                description = "Generate Form";
+                description = 'Generate Form';
                 break;
             case InternalInterface.MG_ACT_GENERATE_PROGRAM:
-                description = "Generate Program";
+                description = 'Generate Program';
                 break;
             case InternalInterface.MG_ACT_GO_TO_TOP:
-                description = "Go to Top";
+                description = 'Go to Top';
                 break;
             case InternalInterface.MG_ACT_H_CENTER_OF_FORM:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_HTML_STYLES:
-                description = "HTML Styles";
+                description = 'HTML Styles';
                 break;
             case InternalInterface.MG_ACT_HELP:
-                description = "Help";
+                description = 'Help';
                 break;
             case InternalInterface.MG_ACT_HELP_SCREENS:
-                description = "Help Screens";
+                description = 'Help Screens';
                 break;
             case InternalInterface.MG_ACT_HORIZ_CENTER:
-                description = "Horiz. Center";
+                description = 'Horiz. Center';
                 break;
             case InternalInterface.MG_ACT_I_O_FILES:
-                description = "Tables";
+                description = 'Tables';
                 break;
             case InternalInterface.MG_ACT_INDENT:
-                description = "Indent";
+                description = 'Indent';
                 break;
             case InternalInterface.MG_ACT_INSERT_OBJECT:
-                description = "Insert Object";
+                description = 'Insert Object';
                 break;
             case InternalInterface.MG_ACT_JUMP_TO_ROW:
-                description = "Jump to Row";
+                description = 'Jump to Row';
                 break;
             case InternalInterface.MG_ACT_KEYBOARD_LIST:
-                description = "Keyboard List";
+                description = 'Keyboard List';
                 break;
             case InternalInterface.MG_ACT_KEYBOARD_MAPPING:
-                description = "Keyboard Mapping";
+                description = 'Keyboard Mapping';
                 break;
             case InternalInterface.MG_ACT_LANGUAGES:
-                description = "languages";
+                description = 'languages';
                 break;
             case InternalInterface.MG_ACT_RTO_SEARCH:
-                description = "Locate Next";
+                description = 'Locate Next';
                 break;
             case InternalInterface.MG_ACT_RTO_LOCATE:
-                description = "Locate a Record";
+                description = 'Locate a Record';
                 break;
             case InternalInterface.MG_ACT_LOGICALPNAMES:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_LOGON:
-                description = "Logon";
+                description = 'Logon';
                 break;
             case InternalInterface.MG_ACT_USING_HELP:
-                description = "Help Topics";
+                description = 'Help Topics';
                 break;
             case InternalInterface.MG_ACT_EDT_MARKNXTCH:
-                description = "Mark Next Char";
+                description = 'Mark Next Char';
                 break;
             case InternalInterface.MG_ACT_MARK_NEXT_LINE:
-                description = "Mark Next Line MLE";
+                description = 'Mark Next Line MLE';
                 break;
             case InternalInterface.MG_ACT_EDT_MARKPRVCH:
-                description = "Mark Previous Char";
+                description = 'Mark Previous Char';
                 break;
             case InternalInterface.MG_ACT_EDT_MARKPRVLINE:
-                description = "Mark Previous Line MLE";
+                description = 'Mark Previous Line MLE';
                 break;
             case InternalInterface.MG_ACT_MARK_SUBTREE:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_EDT_MARKTOBEG:
-                description = "Mark To Beginning";
+                description = 'Mark To Beginning';
                 break;
             case InternalInterface.MG_ACT_EDT_MARKTOEND:
-                description = "Mark To End";
+                description = 'Mark To End';
                 break;
             case InternalInterface.MG_ACT_MAXIMUM_HEIGHT:
-                description = "Maximum Height";
+                description = 'Maximum Height';
                 break;
             case InternalInterface.MG_ACT_MAXIMUM_WIDTH:
-                description = "Maximum Width";
+                description = 'Maximum Width';
                 break;
             case InternalInterface.MG_ACT_MENU_BAR:
-                description = "Menu Bar";
+                description = 'Menu Bar';
                 break;
             case InternalInterface.MG_ACT_MENUS:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_MINIMUM_HEIGHT:
-                description = "Minimum Height";
+                description = 'Minimum Height';
                 break;
             case InternalInterface.MG_ACT_MINIMUM_WIDTH:
-                description = "Minimum Width";
+                description = 'Minimum Width';
                 break;
             case InternalInterface.MG_ACT_RTO_MODIFY:
-                description = "Modify Records";
+                description = 'Modify Records';
                 break;
             case InternalInterface.MG_ACT_MONITOR_DEBUGGER:
-                description = "Monitor/Debugger";
+                description = 'Monitor/Debugger';
                 break;
             case InternalInterface.MG_ACT_MOVE_ENTRY:
-                description = "Move Entry";
+                description = 'Move Entry';
                 break;
             case InternalInterface.MG_ACT_MOVE_SUBTREE:
-                description = "Move Subtree";
+                description = 'Move Subtree';
                 break;
             case InternalInterface.MG_ACT_NULL_SETTINGS:
-                description = "NULL Settings";
+                description = 'NULL Settings';
                 break;
             case InternalInterface.MG_ACT_EDT_NXTCHAR:
-                description = "Next Char";
+                description = 'Next Char';
                 break;
             case InternalInterface.MG_ACT_EDT_NXTLINE:
-                description = "Next Line";
+                description = 'Next Line';
                 break;
             case InternalInterface.MG_ACT_EDT_NXTPAGE:
-                description = "Next Page";
+                description = 'Next Page';
                 break;
             case InternalInterface.MG_ACT_TBL_NXTLINE:
-                description = "Next Row";
+                description = 'Next Row';
                 break;
             case InternalInterface.MG_ACT_TBL_NXTPAGE:
-                description = "Next Screen";
+                description = 'Next Screen';
                 break;
             case InternalInterface.MG_ACT_EDT_NXTTAB:
-                description = "Next Tab";
+                description = 'Next Tab';
                 break;
             case InternalInterface.MG_ACT_EDT_NXTWORD:
-                description = "Next Word";
+                description = 'Next Word';
                 break;
             case InternalInterface.MG_ACT_NORMAL:
-                description = "Normal";
+                description = 'Normal';
                 break;
             case InternalInterface.MG_ACT_OK:
-                description = "OK";
+                description = 'OK';
                 break;
             case InternalInterface.MG_ACT_OLE2:
-                description = "OLE2";
+                description = 'OLE2';
                 break;
             case InternalInterface.MG_ACT_OPEN_APPLICATION:
-                description = "Open Application";
+                description = 'Open Application';
                 break;
             case InternalInterface.MG_ACT_OVERWRITE_ENTRY:
-                description = "Overwrite Entry";
+                description = 'Overwrite Entry';
                 break;
             case InternalInterface.MG_ACT_OVERWRITE_SUBTREE:
-                description = "Overwrite Subtree";
+                description = 'Overwrite Subtree';
                 break;
             case InternalInterface.MG_ACT_PPD:
-                description = "PPD";
+                description = 'PPD';
                 break;
             case InternalInterface.MG_ACT_PAGE_FOOTER:
-                description = "Page Footer";
+                description = 'Page Footer';
                 break;
             case InternalInterface.MG_ACT_PAGE_HEADER:
-                description = "Page Header";
+                description = 'Page Header';
                 break;
             case InternalInterface.MG_ACT_CLIP_PASTE:
-                description = "Paste";
+                description = 'Paste';
                 break;
             case InternalInterface.MG_ACT_PASTE_LINK:
-                description = "Paste Link";
+                description = 'Paste Link';
                 break;
             case InternalInterface.MG_ACT_PASTE_SUBTREE:
-                description = "Paste Subtree";
+                description = 'Paste Subtree';
                 break;
             case InternalInterface.MG_ACT_EDT_PRVCHAR:
-                description = "Previous Char";
+                description = 'Previous Char';
                 break;
             case InternalInterface.MG_ACT_EDT_PRVLINE:
-                description = "Previous Line";
+                description = 'Previous Line';
                 break;
             case InternalInterface.MG_ACT_EDT_PRVPAGE:
-                description = "Previous Page";
+                description = 'Previous Page';
                 break;
             case InternalInterface.MG_ACT_TBL_PRVLINE:
-                description = "Previous Row";
+                description = 'Previous Row';
                 break;
             case InternalInterface.MG_ACT_TBL_PRVPAGE:
-                description = "Previous Screen";
+                description = 'Previous Screen';
                 break;
             case InternalInterface.MG_ACT_EDT_PRVTAB:
-                description = "Previous Tab";
+                description = 'Previous Tab';
                 break;
             case InternalInterface.MG_ACT_EDT_PRVWORD:
-                description = "Previous Word";
+                description = 'Previous Word';
                 break;
             case InternalInterface.MG_ACT_PRINT_ATTRIBUTES:
-                description = "Print Attributes";
+                description = 'Print Attributes';
                 break;
             case InternalInterface.MG_ACT_PRINTER_SETUP:
-                description = "Printer Setup";
+                description = 'Printer Setup';
                 break;
             case InternalInterface.MG_ACT_PRINTERS:
-                description = "Printers";
+                description = 'Printers';
                 break;
             case InternalInterface.MG_ACT_PROGRAMS:
-                description = "Programs";
+                description = 'Programs';
                 break;
             case InternalInterface.MG_ACT_PROPERTIES:
-                description = "Properties";
+                description = 'Properties';
                 break;
             case InternalInterface.MG_ACT_RTO_QUERY:
-                description = "Query Records";
+                description = 'Query Records';
                 break;
             case InternalInterface.MG_ACT_RTO_RANGE:
-                description = "Range of Records";
+                description = 'Range of Records';
                 break;
             case InternalInterface.MG_ACT_RT_REFRESH_RECORD:
-                description = "Record Flush";
+                description = 'Record Flush';
                 break;
             case InternalInterface.MG_ACT_REDIRECT_FILES:
-                description = "Redirect Files";
+                description = 'Redirect Files';
                 break;
             case InternalInterface.MG_ACT_REDRAW_LAYOUT:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_REPEAT_ENTRY:
-                description = "Repeat Entry";
+                description = 'Repeat Entry';
                 break;
             case InternalInterface.MG_ACT_REPEAT_SUBTREE:
-                description = "Repeat Subtree";
+                description = 'Repeat Subtree';
                 break;
             case InternalInterface.MG_ACT_REPORT_GENERATOR:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_RESTORE_DEFAULTS:
-                description = "Restore Defaults";
+                description = 'Restore Defaults';
                 break;
             case InternalInterface.MG_ACT_RETURN_TO_TREE:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_RIGHT:
-                description = "Right";
+                description = 'Right';
                 break;
             case InternalInterface.MG_ACT_RIGHTS:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_RIGHTS_LIST:
-                description = "Rights List";
+                description = 'Rights List';
                 break;
             case InternalInterface.MG_ACT_SQL_ASSIST:
-                description = "SQL Assist";
+                description = 'SQL Assist';
                 break;
             case InternalInterface.MG_ACT_SQL_COLUMNS:
-                description = "SQL Columns";
+                description = 'SQL Columns';
                 break;
             case InternalInterface.MG_ACT_SQL_COMMAND:
-                description = "SQL Command";
+                description = 'SQL Command';
                 break;
             case InternalInterface.MG_ACT_SQL_FLIP_DESC:
-                description = "SQL Flip Desc.";
+                description = 'SQL Flip Desc.';
                 break;
             case InternalInterface.MG_ACT_SQL_KEYWORDS:
-                description = "SQL Keywords";
+                description = 'SQL Keywords';
                 break;
             case InternalInterface.MG_ACT_SQL_OPERATORS:
-                description = "SQL Operators";
+                description = 'SQL Operators';
                 break;
             case InternalInterface.MG_ACT_SQL_TABLES:
-                description = "SQL Tables";
+                description = 'SQL Tables';
                 break;
             case InternalInterface.MG_ACT_SQL_WHERE_CLAUSE:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_RT_REFRESH_SCREEN:
-                description = "Screen Refresh";
+                description = 'Screen Refresh';
                 break;
             case InternalInterface.MG_ACT_SECRET_NAMES:
-                description = "Secret Names";
+                description = 'Secret Names';
                 break;
             case InternalInterface.MG_ACT_SELECT:
-                description = "Select";
+                description = 'Select';
                 break;
             case InternalInterface.MG_ACT_EDT_MARKALL:
-                description = "Select All";
+                description = 'Select All';
                 break;
             case InternalInterface.MG_ACT_SERVERS:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_SERVICES:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_RT_EDT_NULL:
-                description = "Set to NULL";
+                description = 'Set to NULL';
                 break;
             case InternalInterface.MG_ACT_SHELL_TO_OS:
-                description = "Shell to OS";
+                description = 'Shell to OS';
                 break;
             case InternalInterface.MG_ACT_SHOW_EXPRESSION:
-                description = "Show Expression";
+                description = 'Show Expression';
                 break;
             case InternalInterface.MG_ACT_SHOW_FULL_LAYOUT:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_SHRINK_TREE:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_SORT:
-                description = "Sort";
+                description = 'Sort';
                 break;
             case InternalInterface.MG_ACT_SORT_RECORDS:
-                description = "Sort Records";
+                description = 'Sort Records';
                 break;
             case InternalInterface.MG_ACT_TABLE_LOCATE:
-                description = "Table Locate";
+                description = 'Table Locate';
                 break;
             case InternalInterface.MG_ACT_TABLE_LOCATE_NEXT:
-                description = "Table Locate Next";
+                description = 'Table Locate Next';
                 break;
             case InternalInterface.MG_ACT_TABLES:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_TASK_CONTROL:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_TASK_EVENTS:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_TO_VALUE:
-                description = "To Value";
+                description = 'To Value';
                 break;
             case InternalInterface.MG_ACT_TOOLKIT_RUNTIME:
-                description = "Toolkit/Runtime";
+                description = 'Toolkit/Runtime';
                 break;
             case InternalInterface.MG_ACT_TOP:
-                description = "Top";
+                description = 'Top';
                 break;
             case InternalInterface.MG_ACT_TYPES:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_EDT_UNDO:
-                description = "Undo Editing";
+                description = 'Undo Editing';
                 break;
             case InternalInterface.MG_ACT_UNINDENT:
-                description = "Unindent";
+                description = 'Unindent';
                 break;
             case InternalInterface.MG_ACT_UPDATE_LINK:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_USER_ACTION_1:
             case InternalInterface.MG_ACT_USER_ACTION_2:
@@ -3029,100 +3017,100 @@ class Event {
             case InternalInterface.MG_ACT_USER_ACTION_18:
             case InternalInterface.MG_ACT_USER_ACTION_19:
             case InternalInterface.MG_ACT_USER_ACTION_20:
-                description = "User Action " + (internalEventCode - InternalInterface.MG_ACT_USER_ACTION_1 + 1);
+                description = 'User Action ' + (internalEventCode - InternalInterface.MG_ACT_USER_ACTION_1 + 1);
                 break;
             case InternalInterface.MG_ACT_USER_GROUPS:
-                description = "";
+                description = '';
                 break;
             case InternalInterface.MG_ACT_USER_IDS:
-                description = "User IDs";
+                description = 'User IDs';
                 break;
             case InternalInterface.MG_ACT_V_CENTER_OF_FORM:
-                description = "Center of Form";
+                description = 'Center of Form';
                 break;
             case InternalInterface.MG_ACT_VERTICAL_CENTER:
-                description = "Vertical Center";
+                description = 'Vertical Center';
                 break;
             case InternalInterface.MG_ACT_VIEW_BY_KEY:
-                description = "View by Key";
+                description = 'View by Key';
                 break;
             case InternalInterface.MG_ACT_RT_REFRESH_VIEW:
-                description = "View Refresh";
+                description = 'View Refresh';
                 break;
             case InternalInterface.MG_ACT_VIRTUAL_VARIABLES:
-                description = "Variables";
+                description = 'Variables';
                 break;
             case InternalInterface.MG_ACT_VISUAL_CONNECTION:
-                description = "Visual Connection";
+                description = 'Visual Connection';
                 break;
             case InternalInterface.MG_ACT_HIT:
-                description = "Window Hit";
+                description = 'Window Hit';
                 break;
             case InternalInterface.MG_ACT_WINMOVE:
-                description = "Window Reposition";
+                description = 'Window Reposition';
                 break;
             case InternalInterface.MG_ACT_WINSIZE:
-                description = "Window Resize";
+                description = 'Window Resize';
                 break;
             case InternalInterface.MG_ACT_ZOOM:
-                description = "Zoom";
+                description = 'Zoom';
                 break;
             case InternalInterface.MG_ACT_LOCKING_DETAILS:
-                description = "Locking Details";
+                description = 'Locking Details';
                 break;
             case InternalInterface.MG_ACT_LOCKING_ABORT:
-                description = "Locking Abort";
+                description = 'Locking Abort';
                 break;
             case InternalInterface.MG_ACT_LOCKING_RETRY:
-                description = "Locking Retry";
+                description = 'Locking Retry';
                 break;
             case InternalInterface.MG_ACT_CHECK_OBJECT_LIST:
-                description = "Check Object List";
+                description = 'Check Object List';
                 break;
             case InternalInterface.MG_ACT_USERS_LIST:
-                description = "Users List";
+                description = 'Users List';
                 break;
             case InternalInterface.MG_ACT_MODELS:
-                description = "Models";
+                description = 'Models';
                 break;
             case InternalInterface.MG_ACT_WEB_CLICK:
-                description = "Click";
+                description = 'Click';
                 break;
             case InternalInterface.MG_ACT_WEB_ON_DBLICK:
-                description = "DblClick";
+                description = 'DblClick';
                 break;
             case InternalInterface.MG_ACT_BROWSER_ESC:
-                description = "Esc";
+                description = 'Esc';
                 break;
             case InternalInterface.MG_ACT_ROLLBACK:
-                description = "Rollback";
+                description = 'Rollback';
                 break;
             case InternalInterface.MG_ACT_EMPTY_DATAVIEW:
-                description = "Empty Dataview";
+                description = 'Empty Dataview';
                 break;
             case InternalInterface.MG_ACT_CTRL_MODIFY:
-                description = "Control Modify";
+                description = 'Control Modify';
                 break;
             case InternalInterface.MG_ACT_PRINT_DATA:
-                description = "Print Data";
+                description = 'Print Data';
                 break;
             case InternalInterface.MG_ACT_POST_REFRESH_BY_PARENT:
-                description = "Post Refresh by Parent";
+                description = 'Post Refresh by Parent';
                 break;
             case InternalInterface.MG_ACT_SWITCH_TO_OFFLINE:
-                description = "Switch To Offline";
+                description = 'Switch To Offline';
                 break;
             case InternalInterface.MG_ACT_UNAVAILABLE_SERVER:
-                description = "Unavailable Server";
+                description = 'Unavailable Server';
                 break;
             case InternalInterface.MG_ACT_CONTEXT_MENU:
-                description = "Context Menu";
+                description = 'Context Menu';
                 break;
             case InternalInterface.MG_ACT_ENTER_ROW_EDITING:
-                description = "Enter Row Editing";
+                description = 'Enter Row Editing';
                 break;
             case InternalInterface.MG_ACT_NO_PROG_EXE_RIGHTS:
-                description = "No Program Execution Rights";
+                description = 'No Program Execution Rights';
                 break;
             case InternalInterface.MG_ACT_WEBCLIENT_ROUTE:
                 description = 'Route';
@@ -3158,7 +3146,7 @@ class Event {
                 description = 'Index Change';
                 break;
             default:
-                description = "";
+                description = '';
                 break;
         }
         return description;
@@ -3177,37 +3165,34 @@ class Event {
     getKeyboardItemString() {
         let kbi = this.getKbdItm();
         if (kbi === null)
-            return "";
+            return '';
         return kbi.ToString();
     }
     seconds2String() {
         let time = new Array(3);
-        let buffer = "";
+        let buffer = '';
         time[0] = Math.floor(this._seconds / 3600);
         time[1] = Math.floor((this._seconds - time[0] * 3600) / 60);
         time[2] = this._seconds % 60;
         for (let i = 0; i < time.length; i++) {
             if (time[i] === 0)
-                buffer += "00";
+                buffer += '00';
             else if (time[i] < 10)
-                buffer += ("0" + time[i]);
+                buffer += ('0' + time[i]);
             else
                 buffer += time[i];
             if (i < time.length - 1)
-                buffer += ":";
+                buffer += ':';
         }
         return buffer;
     }
-    getParamVal(idx) {
-        return this._paramVals[idx];
-    }
     parseParamVal(valueStr) {
         let startOfs = 0, endOfs = 0, nLen, j;
         let sLen, sValue = null;
         for (j = 0; j < this._parameters; j++) {
             switch (this._paramAttrs[j]) {
                 case StorageAttribute.SKIP:
-                    sValue = "";
+                    sValue = '';
                     break;
                 case StorageAttribute.ALPHA:
                 case StorageAttribute.BLOB_VECTOR:
@@ -3267,88 +3252,9 @@ class Event {
         }
         return endOfs;
     }
-    setParamVals(paramVals_) {
-        this._paramVals = paramVals_;
-        this._paramAttrs = this._paramNulls = "";
-        this._parameters = 0;
-        if (this._paramVals !== null) {
-            this._parameters = this._paramVals.length;
-            for (let i = 0; i < this._parameters; i++) {
-                this._paramAttrs += StorageAttribute.ALPHA;
-                this._paramNulls += "0";
-            }
-        }
-    }
-    setParamType(paramNum, fld) {
-        let currType;
-        let currValue;
-        let newType = fld.getType();
-        let pic = null;
-        let sameType = false;
-        if (this._paramVals != null && this.getParamNum() >= paramNum) {
-            currType = this._paramAttrs[paramNum];
-            sameType = (currType === newType);
-            if (!sameType) {
-                let charArr = null;
-                currValue = this._paramVals[paramNum];
-                switch (newType) {
-                    case StorageAttribute.ALPHA:
-                    case StorageAttribute.BLOB:
-                    case StorageAttribute.BLOB_VECTOR:
-                    case StorageAttribute.MEMO:
-                    case StorageAttribute.UNICODE:
-                        break;
-                    case StorageAttribute.NUMERIC:
-                    case StorageAttribute.DATE:
-                    case StorageAttribute.TIME:
-                        if (currType === StorageAttribute.ALPHA) {
-                            try {
-                                pic = PIC.buildPicture(newType, currValue, fld.getTask().getCompIdx(), true);
-                                this._paramVals[paramNum] = DisplayConvertor.Instance.disp2mg(currValue, pic, fld.getTask().getCompIdx(), BlobType.CONTENT_TYPE_UNKNOWN);
-                                sameType = true;
-                            }
-                            catch (exception) {
-                                if (exception instanceof Exception) {
-                                    sameType = false;
-                                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Event.setParamType() cannot transfer {0} to Numeric with picture {1}", currValue, (pic != null ? pic.getFormat() : "null")));
-                                }
-                                else
-                                    throw exception;
-                            }
-                        }
-                        break;
-                    case StorageAttribute.BOOLEAN:
-                        if (currType === StorageAttribute.ALPHA) {
-                            currValue = currValue.trim();
-                            if (currValue === "1" || currValue.toLowerCase() === "true")
-                                this._paramVals[paramNum] = "1";
-                            else
-                                this._paramVals[paramNum] = "0";
-                            sameType = true;
-                        }
-                        break;
-                }
-                if (sameType) {
-                    charArr = NString.ToCharArray(this._paramAttrs);
-                    charArr[paramNum] = newType;
-                    this._paramAttrs = NString.FromChars(charArr);
-                }
-            }
-        }
-        return sameType;
-    }
     getParamNum() {
         return this._parameters;
     }
-    getParamNull(idx) {
-        if ('0' === this._paramNulls.charAt(idx))
-            return false;
-        else
-            return true;
-    }
-    getParamAttr(idx) {
-        return this._paramAttrs.charAt(idx);
-    }
     isControlHeader() {
         return this.getType() == ConstInterface.EVENT_TYPE_INTERNAL &&
             (this.getInternalCode() == InternalInterface.MG_ACT_CTRL_PREFIX ||
@@ -3380,7 +3286,7 @@ class Event {
                 buffer.Append('ID ' + this.Exp.getId().toString());
                 break;
             default:
-                buffer.Append("unknown event type ");
+                buffer.Append('unknown event type ');
                 break;
         }
     }
@@ -3460,24 +3366,6 @@ class Event {
     getUserDefinedFuncRetExp() {
         return this._returnExp;
     }
-    getOsCommandText() {
-        return this._osCommandText;
-    }
-    setOsCommandText(osCommandText) {
-        this._osCommandText = osCommandText;
-    }
-    getOsCommandWait() {
-        return this._osCommandWait;
-    }
-    setOsCommandWait(wait) {
-        this._osCommandWait = wait;
-    }
-    getOsCommandShow() {
-        return this._osCommandShow;
-    }
-    setOsCommandShow(osShow) {
-        this._osCommandShow = osShow;
-    }
     setTimestamp() {
         this._timestamp = Event._lastTimestamp++;
     }
@@ -3485,7 +3373,7 @@ class Event {
         return this._timestamp;
     }
     toString() {
-        return NString.Format("{{Event: {0}}}", this.getBrkLevel());
+        return NString.Format('{{Event: {0}}}', this.getBrkLevel());
     }
 }
 Event._lastTimestamp = 0;
@@ -3552,7 +3440,6 @@ class MgPriorityBlockingQueue {
         return this._queue.peek();
     }
     size() {
-        let size;
         return this._queue.Size;
     }
     remainingCapacity() {
@@ -3562,7 +3449,6 @@ class MgPriorityBlockingQueue {
         this._queue.clear();
     }
     isEmpty() {
-        let result;
         return this._queue.isEmpty();
     }
 }
@@ -4294,7 +4180,6 @@ FlowMonitorQueue.S_EVENT_STR1 = ">>Starts ";
 FlowMonitorQueue.S_EVENT_STR2 = " Event";
 FlowMonitorQueue.S_EVENT_PROPAGATED = "Event was propagated";
 FlowMonitorQueue.E_EVENT_STR = "<<Ends Event";
-FlowMonitorQueue.TSK_CHNG_MODE = "Task Mode Change - ";
 FlowMonitorQueue.S_RECPRF_STR = "Starts Record Prefix";
 FlowMonitorQueue.E_RECPRF_STR = "Ends Record Prefix";
 FlowMonitorQueue.S_RECSUF_STR = "Starts Record Suffix";
@@ -4315,17 +4200,7 @@ FlowMonitorQueue.RECOMP_STR = "Recomputes - ";
 FlowMonitorQueue.S_VARIABLE_STR = "Starts Variable Change - ";
 FlowMonitorQueue.E_VARIABLE_STR = "Ends Variable Change - ";
 FlowMonitorQueue.VARIABLE_REASON_STR = " - Reason - Previous value";
-FlowMonitorQueue.INFORM_STR = " >> INFORMATION >> ";
-FlowMonitorQueue.FLW_STEP_FWD = "(Step Forward)";
-FlowMonitorQueue.FLW_FAST_FWD = "(Fast Forward)";
-FlowMonitorQueue.FLW_STEP_BWD = "(Step Backward)";
-FlowMonitorQueue.FLW_FAST_BWD = "(Fast Backward)";
-FlowMonitorQueue.FLW_NOT_EXEC = "[Not Executed]";
-FlowMonitorQueue.FLW_FORWARD = "(Forward)";
-FlowMonitorQueue.FLW_BACKWARD = "(Backward)";
 FlowMonitorQueue.FLW_PERFIX = "Flow - ";
-FlowMonitorQueue.S_UPDATE_STR = "Starts Update";
-FlowMonitorQueue.E_UPDATE_STR = "Ends Update";
 FlowMonitorQueue.ACT_TASK = 'T';
 FlowMonitorQueue.ACT_TASK_FLW = 'F';
 FlowMonitorQueue.ACT_RECOMPUTE = 'R';
@@ -4333,12 +4208,10 @@ FlowMonitorQueue.ACT_FLW_OPER = 'T';
 FlowMonitorQueue.LongTimePattern = "HH:mm:ss:SSS";
 class ActivityItem {
     constructor(enclosingInstance, type, id) {
-        this._enclosingInstance = null;
         this._id = 0;
         this._type = null;
         this._info = null;
         this._time = null;
-        this._enclosingInstance = enclosingInstance;
         this._type = type;
         this._id = id;
         this.setTime();
@@ -4779,8 +4652,6 @@ HttpClientEvents.GetSessionCounter_Event = null;
 HttpClientEvents.CheckAndSetSessionCounter_Event = null;
 HttpClientEvents.ComputeAndLogRequestInfo_Event = null;
 
-const HTTP_EXPECT100CONTINUE = "Expect100Continue";
-const USE_HIGHEST_SECURITY_PROTOCOL = "UseHighestSecurityProtocol";
 var RequestMethod;
 (function (RequestMethod) {
     RequestMethod[RequestMethod["Get"] = 0] = "Get";
@@ -4905,20 +4776,6 @@ class HttpClientBase {
         }
         return headersStr;
     }
-    static GetHTTPExpect100Continue() {
-        let result = true;
-        let executionProperty = HttpClientEvents.GetExecutionProperty(HTTP_EXPECT100CONTINUE);
-        if (!NString.IsNullOrEmpty(executionProperty))
-            result = (executionProperty.toUpperCase() === "Y");
-        return result;
-    }
-    static GetUseHighestSecurityProtocol() {
-        let result = false;
-        let executionProperty = HttpClientEvents.GetExecutionProperty(USE_HIGHEST_SECURITY_PROTOCOL);
-        if (!NString.IsNullOrEmpty(executionProperty))
-            result = (executionProperty.toUpperCase() === "Y");
-        return result;
-    }
     sendRequestToServer(httpMethod, urlString, httpHeaders, requestContent, contentFromServer) {
         return __awaiter(this, void 0, void 0, function* () {
             return Promise.resolve();
@@ -6141,9 +5998,7 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
                     AccessHelper.eventsManager.CheckAndShowSpinner(true);
                 });
                 let isError = new RefParam(false);
-                RemoteCommandsProcessor.requestNumber++;
                 responseStr = yield HttpManager.GetInstance().GetContent(requestedURL, requestContent, useCache, isError);
-                RemoteCommandsProcessor.totalResponseDataLength += RemoteCommandsProcessor.totalResponseDataLength + (!isNullOrUndefined(responseStr) ? responseStr.length : 0);
                 spinnerTimerSubscription.unsubscribe();
                 spinnerTimerSubscription = null;
                 if (isError.value) {
@@ -6237,10 +6092,7 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
             let extraMessageStr = isLoggingResponse ? 'Response ⤵' : 'Request ⤵';
             if (isLoggingResponse) {
                 this._requestInfo.roundtripTime = roundTrip;
-                RemoteCommandsProcessor.totalTimeForHTTPRequests += roundTrip;
             }
-            else
-                RemoteCommandsProcessor.totalRequestDataLength += contentLength;
             Logger.Instance.WriteRequestInfoToLog(this._requestInfo, extraMessageStr);
             if (isLoggingResponse)
                 this._requestInfo.clear();
@@ -6322,10 +6174,6 @@ RemoteCommandsProcessor._instance = null;
 RemoteCommandsProcessor.IsSessionReInitializing = false;
 RemoteCommandsProcessor.lastExceptionMessage = null;
 RemoteCommandsProcessor.InitialUrl = null;
-RemoteCommandsProcessor.requestNumber = 0;
-RemoteCommandsProcessor.totalTimeForHTTPRequests = 0;
-RemoteCommandsProcessor.totalRequestDataLength = 0;
-RemoteCommandsProcessor.totalResponseDataLength = 0;
 RemoteCommandsProcessor.WEB_COMMUNICATION_PROTOCOL_VERSION = "14002";
 RemoteCommandsProcessor._shouldScrambleAndUnscrambleMessages = false;
 class HandshakeResponse {
@@ -6733,7 +6581,6 @@ class LanguageData {
             try {
                 if (this._mlsContent != null) {
                     if (this._mlsContent.length > 0) {
-                        let contentLen = this._mlsContent.length;
                         let linePairs = 0;
                         let srcLine = this._mlsContent + 3;
                         this._mlsStrings = new Hashtable();
@@ -6803,7 +6650,6 @@ class GUIManager {
     }
     abort_0(form) {
         if (form !== null) {
-            let mainProgByCtlIdx = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, form.getTask().getCtlIdx());
             Manager.Abort(form);
         }
     }
@@ -7969,7 +7815,6 @@ class EventHandlerPosition {
     getNext_1() {
         if (this._handlersTab === null)
             return null;
-        let result;
         if (this._rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && this._rtEvt.getInternalCode() !== InternalInterface.MG_ACT_VARIABLE) {
             switch (this._rtEvt.getInternalCode()) {
                 case InternalInterface.MG_ACT_TASK_PREFIX:
@@ -8384,7 +8229,7 @@ class RecomputeCommand extends ClientOriginatedCommandTaskTag {
         helper.SerializeTaskTag(this.TaskTag);
         helper.SerializeFldId(this.FldId);
         if (this.IgnoreSubformRecompute)
-            helper.SerializeAttribute(ConstInterface.MG_ATTR_IGNORE_SUBFORM_RECOMPUTE, "1");
+            helper.SerializeAttribute(ConstInterface.MG_ATTR_IGNORE_SUBFORM_RECOMPUTE, '1');
         return helper.GetString();
     }
     getCommandInfo() {
@@ -8528,7 +8373,7 @@ class ContextTimeoutResetCommand extends EventCommand {
     SerializeCommandData() {
         let helper = new CommandSerializationHelper();
         helper.SerializeMagicEvent(this.MagicEvent);
-        helper.SerializeAttribute(ConstInterface.MG_ATTR_OBJECT, "1");
+        helper.SerializeAttribute(ConstInterface.MG_ATTR_OBJECT, '1');
         return helper.GetString();
     }
     getCommandInfo() {
@@ -8626,7 +8471,7 @@ class CommandFactory {
                 }
                 if (argList.getSize() > 1) {
                     try {
-                        cmd.KeepUserSort = ((yield argList.getArgValue(1, StorageAttribute.BOOLEAN, 0)) === "1");
+                        cmd.KeepUserSort = ((yield argList.getArgValue(1, StorageAttribute.BOOLEAN, 0)) === '1');
                     }
                     catch (e) {
                         cmd.KeepUserSort = false;
@@ -8761,7 +8606,7 @@ class CommandFactory {
         execOperCommand.DitIdx = ditIdx;
         let cmd = execOperCommand;
         if (value !== null && value.length === 0)
-            cmd.Val = " ";
+            cmd.Val = ' ';
         else
             cmd.Val = value;
         return cmd;
@@ -8774,7 +8619,7 @@ class CommandFactory {
         execOperCommand.DitIdx = ditIdx;
         let cmd = execOperCommand;
         if (value !== null && value.length === 0)
-            cmd.Val = " ";
+            cmd.Val = ' ';
         else
             cmd.Val = value;
         return cmd;
@@ -8969,7 +8814,6 @@ class Environment {
         this._contextInactivityWarningTime = 0;
         this._toolitipTimeout = 0;
         this._contextUnloadTimeout = 0;
-        this._accessTest = false;
         this._canReplaceDecimalSeparator = false;
         this._codePage = 0;
         this._dateSeparator = '\0';
@@ -9051,7 +8895,6 @@ class Environment {
         let valueStr;
         let hashKey;
         let env;
-        let utilImeJpn = Manager.UtilImeJpn;
         env = new EnvironmentDetails();
         for (let j = 0; j < tokensVector.length; j += 2) {
             attribute = (tokensVector.get_Item(j));
@@ -9093,7 +8936,6 @@ class Environment {
                     this._lowHigh = XmlParser.getBoolean(valueStr);
                     break;
                 case ConstInterface.MG_ATTR_ACCESS_TEST:
-                    this._accessTest = XmlParser.getBoolean(valueStr);
                     break;
                 case ConstInterface.MG_ATTR_SPECIAL_TEXT_SIZE_FACTORING:
                     this._specialTextSizeFactoring = XmlParser.getBoolean(valueStr);
@@ -9715,18 +9557,14 @@ class Operation {
         this._execOnClient = false;
         this._exp = null;
         this._field = null;
-        this._globalParamsShouldBeCopied = false;
         this._image = '\0';
         this._incremental = false;
-        this._methodNameSnippet = null;
         this._mode = '\0';
-        this._prgDescription = null;
         this._publicName = null;
         this._returnVal = null;
         this._rtEvt = null;
         this._serverId = -1;
         this.calledTaskDefinitionId = null;
-        this._show = CallOsShow.Normal;
         this._subformCtrlName = null;
         this._subtype = '\0';
         this._task = null;
@@ -9800,7 +9638,6 @@ class Operation {
     initElements(tokensVector, taskRef) {
         let attribute, valueStr;
         let expId;
-        let isGuiThreadExecution = false;
         for (let j = 0; j < tokensVector.length; j += 2) {
             attribute = (tokensVector.get_Item(j));
             valueStr = (tokensVector.get_Item(j + 1));
@@ -9860,7 +9697,6 @@ class Operation {
                     this._syncData.setVal(taskRef, valueStr);
                     break;
                 case ConstInterface.MG_ATTR_SHOW:
-                    this._show = XmlParser.getInt(valueStr);
                     break;
                 case ConstInterface.MG_ATTR_CND:
                     this._condExp.setVal(taskRef, valueStr);
@@ -9888,10 +9724,8 @@ class Operation {
                     this._publicName = valueStr;
                     break;
                 case ConstInterface.MG_ATTR_PRG_DESCRIPTION:
-                    this._prgDescription = valueStr;
                     break;
                 case ConstInterface.MG_ATTR_CPY_GLB_PRMS:
-                    this._globalParamsShouldBeCopied = XmlParser.getBoolean(valueStr);
                     break;
                 case ConstInterface.MG_ATTR_EXEC_ON_SERVER:
                     this._execOnServer = XmlParser.getBoolean(valueStr);
@@ -9919,10 +9753,8 @@ class Operation {
                     this._errLogAppend = XmlParser.getBoolean(valueStr);
                     break;
                 case ConstInterface.MG_ATTR_OPER_METHODNAME:
-                    this._methodNameSnippet = valueStr;
                     break;
                 case ConstInterface.MG_ATTR_IS_GUI_THREAD_EXECUTION:
-                    isGuiThreadExecution = XmlParser.getBoolean(valueStr);
                     break;
                 case ConstInterface.MG_ATTR_IS_ROUTE:
                     this._isRoute = XmlParser.getBoolean(valueStr);
@@ -11074,7 +10906,6 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
             let val6;
             let val7;
             let val8;
-            let val9;
             let dynOper = new DynamicOperation();
             let whole;
             let dec;
@@ -13288,7 +13119,6 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
             let tmpVal = new ExpVal();
             tmpVal.MgNumVal = new NUM_TYPE();
             tmpVal.Attr = StorageAttribute.NUMERIC;
-            let expVal = tmpVal;
             if (difDateVal.MgNumVal === null || difTimeVal.MgNumVal === null) {
                 resVal.Attr = StorageAttribute.BOOLEAN;
                 resVal.BoolVal = false;
@@ -15056,9 +14886,6 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
         if (expiresDate) {
             let breakParams = DisplayConvertor.Instance.getNewDateBreakParams();
             DisplayConvertor.Instance.date_break_datemode(breakParams, expiresDate, false, this.ExpTask.getCompIdx());
-            let year = breakParams.year;
-            let month = breakParams.month;
-            let day = breakParams.day;
             if (breakParams.year == 0 && breakParams.month == 0 && breakParams.day == 0)
                 return null;
             nativeDt = new Date(breakParams.year, breakParams.month - 1, breakParams.day);
@@ -17919,14 +17746,14 @@ const SET_DISPLAYLINE_BY_DV = Int32.MinValue;
 const COMPUTE_NEWREC_ON_CLIENT = 'C';
 const UNKNOWN_RCMPS_NOT_INITED = 'M';
 const UNKNOWN_RCMPS_FOUND = 'Y';
-const INVOKED_FROM_OFFLINE_TASK = "-99999";
+const INVOKED_FROM_OFFLINE_TASK = '-99999';
 const CHUNK_CACHE_NEXT = 'N';
 const CHUNK_CACHE_PREV = 'P';
 const CHUNK_DV_BOTTOM = 'B';
 const CHUNK_DV_TOP = 'T';
 const COMPUTE_FLUSH_UPDATES = 'H';
 const COMPUTE_NEWREC_ON_SERVER = 'S';
-const END_DV_TAG = "</" + ConstInterface.MG_TAG_DATAVIEW + ">";
+const END_DV_TAG = '</' + ConstInterface.MG_TAG_DATAVIEW + '>';
 const RECOVERY_ACT_BEGIN_SCREEN = 'S';
 const RECOVERY_ACT_BEGIN_TABLE = 'T';
 const RECOVERY_ACT_CANCEL = 'C';
@@ -17940,7 +17767,6 @@ class DataView extends DataViewBase {
         this._cacheLruTimeStamp = 0;
         this._changed = false;
         this._chunkSize = 30;
-        this._chunkSizeExpression = 0;
         this._computeBy = '\0';
         this._currRecId = 0;
         this._currRecIdx = 0;
@@ -18041,7 +17867,7 @@ class DataView extends DataViewBase {
         if (foundTagName === null)
             return false;
         if (foundTagName === XMLConstants.MG_TAG_DVHEADER) {
-            Logger.Instance.WriteDevToLog("dvheader found");
+            Logger.Instance.WriteDevToLog('dvheader found');
             this.getHeaderAttributes(parser);
             this._fieldsTab.fillData(parser, this);
             this._fieldsTab.setRMPos(this._rmSize, this._rmIdx);
@@ -18069,7 +17895,7 @@ class DataView extends DataViewBase {
                 valueStr = (tokensVector.get_Item(j + 1));
                 switch (attribute) {
                     case ConstInterface.MG_ATTR_RMPOS: {
-                        let i = valueStr.indexOf(",");
+                        let i = valueStr.indexOf(',');
                         if (i > -1) {
                             this._rmSize = NNumber.Parse(valueStr.substr(0, i));
                             this._rmIdx = NNumber.Parse(valueStr.substr(i + 1));
@@ -18092,10 +17918,9 @@ class DataView extends DataViewBase {
                         this._chunkSize = XmlParser.getInt(valueStr);
                         break;
                     case ConstInterface.MG_ATTR_CHUNK_SIZE_EXPRESSION:
-                        this._chunkSizeExpression = XmlParser.getInt(valueStr);
                         break;
                     default:
-                        Logger.Instance.WriteExceptionToLogWithMsg("Unknown attribute for <" + XMLConstants.MG_TAG_DVHEADER + "> tag: " +
+                        Logger.Instance.WriteExceptionToLogWithMsg('Unknown attribute for <' + XMLConstants.MG_TAG_DVHEADER + '> tag: ' +
                             attribute);
                         break;
                 }
@@ -18103,7 +17928,7 @@ class DataView extends DataViewBase {
             parser.setCurrIndex(++endContext);
             return;
         }
-        Logger.Instance.WriteExceptionToLogWithMsg("in DataView.getHeaderAttributes(): out of bounds");
+        Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getHeaderAttributes(): out of bounds');
     }
     fillData(parser) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -18406,7 +18231,7 @@ class DataView extends DataViewBase {
                             this._serverTransCacheEmpty = XmlParser.getBoolean(valueStr);
                             break;
                         default:
-                            Logger.Instance.WriteExceptionToLogWithMsg("Unknown attribute for <" + ConstInterface.MG_TAG_DATAVIEW + "> tag: " + attribute);
+                            Logger.Instance.WriteExceptionToLogWithMsg('Unknown attribute for <' + ConstInterface.MG_TAG_DATAVIEW + '> tag: ' + attribute);
                             break;
                     }
                 }
@@ -18414,7 +18239,7 @@ class DataView extends DataViewBase {
                 parser.setCurrIndex(++endContext);
                 return invalidate;
             }
-            Logger.Instance.WriteExceptionToLogWithMsg("in DataView.getAttributes(): out of bounds");
+            Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getAttributes(): out of bounds');
             return false;
         });
     }
@@ -18444,7 +18269,7 @@ class DataView extends DataViewBase {
             if (dcv !== null)
                 this.AddDcValues(dcv);
             else
-                Logger.Instance.WriteExceptionToLogWithMsg("Error while parsing DC values at position " + dcValsPosition);
+                Logger.Instance.WriteExceptionToLogWithMsg('Error while parsing DC values at position ' + dcValsPosition);
             foundTagName = parser.getNextTag();
         }
     }
@@ -18467,8 +18292,8 @@ class DataView extends DataViewBase {
         let tokensVector;
         const endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
         let attribute;
-        let taskId = "";
-        let handlerId = "";
+        let taskId = '';
+        let handlerId = '';
         let operIdx = 0;
         if (endContext !== -1 && endContext < parser.getXMLdata().length) {
             let tag = parser.getXMLsubstring(endContext);
@@ -18493,7 +18318,7 @@ class DataView extends DataViewBase {
             parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
         }
         else
-            Logger.Instance.WriteExceptionToLogWithMsg("in DataView.fillInnerExecStack() out of bounds");
+            Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fillInnerExecStack() out of bounds');
     }
     peekInvalidate(tokensVector) {
         let sessionCounter = CommandsProcessorManager.GetCommandsProcessor().GetSessionCounter();
@@ -18518,7 +18343,7 @@ class DataView extends DataViewBase {
     getFieldByName(fldName) {
         if (this._fieldsTab !== null)
             return this._fieldsTab.getField(fldName);
-        Logger.Instance.WriteExceptionToLogWithMsg("in DataView.getField(String): There is no fieldsTab object");
+        Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getField(String): There is no fieldsTab object');
         return null;
     }
     buildXML(message) {
@@ -18530,10 +18355,10 @@ class DataView extends DataViewBase {
             let serverParent;
             let contextTask = (this.getTask().GetContextTask());
             let invokingTaskTag = contextTask.IsOffline ? INVOKED_FROM_OFFLINE_TASK : contextTask.getTaskTag();
-            message.Append("\n      <" + ConstInterface.MG_TAG_DATAVIEW + " " + XMLConstants.MG_ATTR_TASKID + "=\"" +
-                taskTag + "\"");
-            message.Append(" " + ConstInterface.MG_ATTR_TASKLEVEL + "=\"" + brkLevelIndex + "\"");
-            serverParent = "0";
+            message.Append('\n      <' + ConstInterface.MG_TAG_DATAVIEW + ' ' + XMLConstants.MG_ATTR_TASKID + '="' +
+                taskTag + '"');
+            message.Append(' ' + ConstInterface.MG_ATTR_TASKLEVEL + '="' + brkLevelIndex + '"');
+            serverParent = '0';
             let triggeringTask = this.getTask().getTriggeringTask();
             if (triggeringTask != null) {
                 if (triggeringTask.IsOffline) {
@@ -18546,42 +18371,42 @@ class DataView extends DataViewBase {
             }
             if (this._currRecId > Int32.MinValue) {
                 if (this.CurrRec != null)
-                    message.Append(" " + ConstInterface.MG_ATTR_CURR_REC + "=\"" + this._currRecId + "\"");
-                message.Append(" " + ConstInterface.MG_ATTR_TASKMODE + "=\"" + this._task.getMode() + "\"");
+                    message.Append(' ' + ConstInterface.MG_ATTR_CURR_REC + '="' + this._currRecId + '"');
+                message.Append(' ' + ConstInterface.MG_ATTR_TASKMODE + '="' + this._task.getMode() + '"');
                 if (this._transCleared && !(MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI)) {
-                    message.Append(" " + ConstInterface.MG_ATTR_TRANS_CLEARED + "=\"1\"");
+                    message.Append(' ' + ConstInterface.MG_ATTR_TRANS_CLEARED + '="1"');
                     this._transCleared = false;
                 }
-                message.Append(" " + ConstInterface.MG_ATTR_INVOKER_ID + "=\"" + invokingTaskTag + "," + serverParent + "\"");
+                message.Append(' ' + ConstInterface.MG_ATTR_INVOKER_ID + '="' + invokingTaskTag + ',' + serverParent + '"');
                 if (yield this.getTask().isCached())
-                    message.Append(" " + ConstInterface.MG_ATTR_DVPOS_VALUE + "=\"" + this._dvPosValue + "\"");
-                message.Append(" " + ConstInterface.MG_ATTR_LOOP_COUNTER + "=\"" + this.getTask().getLoopCounter() + "\"");
+                    message.Append(' ' + ConstInterface.MG_ATTR_DVPOS_VALUE + '="' + this._dvPosValue + '"');
+                message.Append(' ' + ConstInterface.MG_ATTR_LOOP_COUNTER + '="' + this.getTask().getLoopCounter() + '"');
                 if (this._task.IsSubForm) {
                     let subformCtrl = this._task.getForm().getSubFormCtrl();
                     if (!subformCtrl.isVisible() &&
                         !(yield subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false)))
-                        message.Append(" " + ConstInterface.MG_ATTR_SUBFORM_VISIBLE + "=\"0\"");
+                        message.Append(' ' + ConstInterface.MG_ATTR_SUBFORM_VISIBLE + '="0"');
                 }
                 if (!this._task.IsInteractive)
-                    message.Append(" " + ConstInterface.MG_ATTR_TASK_COUNTER + "=\"" + this.getTask().getCounter() + "\"");
+                    message.Append(' ' + ConstInterface.MG_ATTR_TASK_COUNTER + '="' + this.getTask().getCounter() + '"');
                 if (this._task != null && this._task.GetComputedProperty(PropInterface.PROP_TYPE_PRELOAD_VIEW).GetComputedValueBoolean()) {
-                    message.Append(" " + ConstInterface.MG_ATTR_LAST_REC_ID + "=\"" +
-                        (this._recordsTab.getRecByIdx(this.getSize() - 1).getId()) + "\"");
-                    message.Append(" " + ConstInterface.MG_ATTR_OLD_FIRST_REC_ID + "=\"" +
-                        this._recordsTab.getRecByIdx(0).getId() + "\"");
+                    message.Append(' ' + ConstInterface.MG_ATTR_LAST_REC_ID + '="' +
+                        (this._recordsTab.getRecByIdx(this.getSize() - 1).getId()) + '"');
+                    message.Append(' ' + ConstInterface.MG_ATTR_OLD_FIRST_REC_ID + '="' +
+                        this._recordsTab.getRecByIdx(0).getId() + '"');
                 }
                 if (this._task.IsInteractive) {
                     let form = this._task.getForm();
                     if (form != null && this._recordsTab.getSize() > 1) {
-                        message.Append(" " + ConstInterface.MG_ATTR_CURR_REC_POS_IN_FORM + "=\"" +
-                            form.getCurrRecPosInForm() + "\"");
+                        message.Append(' ' + ConstInterface.MG_ATTR_CURR_REC_POS_IN_FORM + '="' +
+                            form.getCurrRecPosInForm() + '"');
                     }
                 }
                 message.Append(XMLConstants.TAG_CLOSE);
                 if (this.getTask().ResetRange || this.getTask().UserRngs != null) {
                     message.Append(XMLConstants.START_TAG + ConstInterface.USER_RANGES);
                     if (this.getTask().ResetRange) {
-                        message.Append(" " + ConstInterface.CLEAR_RANGE + "=\"1\"");
+                        message.Append(' ' + ConstInterface.CLEAR_RANGE + '="1"');
                         this.getTask().ResetRange = false;
                     }
                     if (this.getTask().UserRngs != null) {
@@ -18595,7 +18420,7 @@ class DataView extends DataViewBase {
                 if (this.getTask().ResetLocate || this.getTask().UserLocs != null) {
                     message.Append(XMLConstants.START_TAG + ConstInterface.USER_LOCATES);
                     if (this.getTask().ResetLocate) {
-                        message.Append(" " + ConstInterface.CLEAR_LOCATES + "=\"1\"");
+                        message.Append(' ' + ConstInterface.CLEAR_LOCATES + '="1"');
                         this.getTask().ResetLocate = false;
                     }
                     if (this.getTask().UserLocs != null) {
@@ -18609,7 +18434,7 @@ class DataView extends DataViewBase {
                 if (this.getTask().ResetSort || this.getTask().UserSorts != null) {
                     message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_SORTS);
                     if (this.getTask().ResetSort) {
-                        message.Append(" " + ConstInterface.CLEAR_SORTS + "=\"1\"");
+                        message.Append(' ' + ConstInterface.CLEAR_SORTS + '="1"');
                         this.getTask().ResetSort = false;
                     }
                     if (this.getTask().UserSorts != null)
@@ -18619,10 +18444,10 @@ class DataView extends DataViewBase {
                 }
                 if (yield this.getTask().isCached()) {
                     let delList = this.getTask().getTaskCache().getDeletedListToXML();
-                    if (delList !== "") {
+                    if (delList !== '') {
                         message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_DEL_LIST);
-                        message.Append(" " + XMLConstants.MG_ATTR_ID + "=\"" + this._task.getTaskTag() + "\"");
-                        message.Append(" " + ConstInterface.MG_ATTR_REMOVE + "=\"" + delList + "\"");
+                        message.Append(' ' + XMLConstants.MG_ATTR_ID + '="' + this._task.getTaskTag() + '"');
+                        message.Append(' ' + ConstInterface.MG_ATTR_REMOVE + '="' + delList + '"');
                         message.Append(XMLConstants.TAG_TERM);
                         if (this.getTask().getTaskCache().isDeleted(this._dvPosValue))
                             this.setChanged(true);
@@ -18634,8 +18459,8 @@ class DataView extends DataViewBase {
                     dcv = this._dcValsCollection.get_Item(dcValKey);
                     if (!dcv.HasReferences) {
                         message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_DC_VALS);
-                        message.Append(" " + XMLConstants.MG_ATTR_ID + "=\"" + dcv.getId() + "\"");
-                        message.Append(" " + ConstInterface.MG_ATTR_REMOVE + "=\"1\"");
+                        message.Append(' ' + XMLConstants.MG_ATTR_ID + '="' + dcv.getId() + '"');
+                        message.Append(' ' + ConstInterface.MG_ATTR_REMOVE + '="1"');
                         message.Append(XMLConstants.TAG_TERM);
                         this._dcValsCollection.Remove(dcValKey);
                     }
@@ -18661,15 +18486,15 @@ class DataView extends DataViewBase {
                 }
             }
             else {
-                message.Append(" " + ConstInterface.MG_ATTR_INVOKER_ID + "=\"" + invokingTaskTag + "," + serverParent + "\"" +
+                message.Append(' ' + ConstInterface.MG_ATTR_INVOKER_ID + '="' + invokingTaskTag + ',' + serverParent + '"' +
                     XMLConstants.TAG_CLOSE);
             }
-            message.Append("\n      </" + ConstInterface.MG_TAG_DATAVIEW + XMLConstants.TAG_CLOSE);
+            message.Append('\n      </' + ConstInterface.MG_TAG_DATAVIEW + XMLConstants.TAG_CLOSE);
         });
     }
     getCurrRec() {
         if (this.CurrRec === null && this._currRecId > Int32.MinValue) {
-            Logger.Instance.WriteExceptionToLogWithMsg("DataView.getCurrRec(): record " + this._currRecId + " not found");
+            Logger.Instance.WriteExceptionToLogWithMsg('DataView.getCurrRec(): record ' + this._currRecId + ' not found');
         }
         return this.CurrRec;
     }
@@ -18769,7 +18594,7 @@ class DataView extends DataViewBase {
                 else if (this._recordsTab.getSize() === 0 && this.IncludesFirst())
                     yield this.fetchChunkFromServer(CHUNK_DV_TOP, doSuffix);
                 else
-                    Logger.Instance.WriteExceptionToLogWithMsg("in DataView.fetchChunkFromServer() wrong option");
+                    Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fetchChunkFromServer() wrong option');
                 let oldFirstNewIdx = oldFirstRec != null
                     ? this._recordsTab.getRecIdx(oldFirstRec.getId())
                     : this._recordsTab.getSize();
@@ -18831,7 +18656,7 @@ class DataView extends DataViewBase {
                 }
                 this.CurrRec = this._recordsTab.getRecByIdx(newIdx);
                 if (this.CurrRec == null)
-                    throw new ApplicationException("in DataView.setCurrRecByIdx() current record not found!");
+                    throw new ApplicationException('in DataView.setCurrRecByIdx() current record not found!');
                 this._currRecId = this.CurrRec.getId();
                 this._currRecIdx = newIdx;
                 if (this._task.getForm() != null) {
@@ -18886,7 +18711,7 @@ class DataView extends DataViewBase {
                     clientRecId = this.LastRecord == null ? 0 : this.LastRecord.getId();
                     break;
                 default:
-                    Logger.Instance.WriteExceptionToLogWithMsg("in DataView.fetchChunkFromServer() unknown chunk id: " + chunkId);
+                    Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fetchChunkFromServer() unknown chunk id: ' + chunkId);
                     return;
             }
             let cmd = CommandFactory.CreateEventCommand(this._task.getTaskTag(), eventCode);
@@ -18912,9 +18737,9 @@ class DataView extends DataViewBase {
     getCurrRecIdx() {
         if (this._currRecIdx === Int32.MinValue) {
             if (!this.setCurrRec(this._currRecId, true)) {
-                Logger.Instance.WriteWarningToLogWithMsg("DataView.getCurrRecIdx(): _task " +
+                Logger.Instance.WriteWarningToLogWithMsg('DataView.getCurrRecIdx(): _task ' +
                     (this.getTask()).PreviouslyActiveTaskId +
-                    ", record " + this._currRecId + " not found");
+                    ', record ' + this._currRecId + ' not found');
             }
         }
         return this._currRecIdx;
@@ -19064,7 +18889,7 @@ class DataView extends DataViewBase {
                     if (AccessHelper.eventsManager.GetStopExecutionFlag())
                         newCurrRecIdx = -1;
                     else
-                        throw new ApplicationException("in DataView.addRecord() invalid exception");
+                        throw new ApplicationException('in DataView.addRecord() invalid exception');
                 }
                 else
                     throw execption;
@@ -19474,7 +19299,7 @@ class DataView extends DataViewBase {
             }
             catch (ex) {
                 if (ex instanceof RecordOutOfDataViewException) {
-                    Logger.Instance.WriteDevToLog("wrong top record idx in DataView.setSameAs" + ex.Message);
+                    Logger.Instance.WriteDevToLog('wrong top record idx in DataView.setSameAs' + ex.Message);
                 }
                 else
                     throw ex;
@@ -19560,7 +19385,7 @@ class DataView extends DataViewBase {
                             if (field.isNull())
                                 val = field.getNullDisplay();
                             val = val.trim();
-                            params.push(val.length === 0 ? " " : val);
+                            params.push(val.length === 0 ? ' ' : val);
                         }
                         break;
                     case StorageAttribute.BOOLEAN:
@@ -19576,7 +19401,7 @@ class DataView extends DataViewBase {
                         if (field.isNull())
                             val = field.getNullDisplay();
                         let pic = new PIC(field.getPicture(), field.getType(), this.getTask().getCompIdx());
-                        val = DisplayConvertor.Instance.mg2disp(val, "", pic, true, 0, false);
+                        val = DisplayConvertor.Instance.mg2disp(val, '', pic, true, 0, false);
                         params.push(val);
                         break;
                     }
@@ -19592,17 +19417,12 @@ class DvCache {
         this._cacheTable = null;
         this._deletedList = null;
         this._task = null;
-        this._cacheSize = 0;
-        this._recordsBeforeCurrentView = 0;
-        this._totalRecordsCount = 0;
         this._task = tsk;
         this._cacheTable = new Hashtable(100, 0.7);
         this._deletedList = new List();
-        this._cacheSize = 0;
     }
     putInCache(repOfOriginal) {
         let hashKey = repOfOriginal.getDvPosValue();
-        let insertedSize = repOfOriginal.getSize() * (repOfOriginal.getCurrRec()).getRecSize();
         if (this._cacheTable.get_Item(hashKey) !== null)
             this.removeDvFromCache(hashKey, false);
         repOfOriginal.setCacheLRU();
@@ -19610,15 +19430,11 @@ class DvCache {
         repOfOriginal.zeroServerCurrRec();
         this._cacheTable.set_Item(hashKey, repOfOriginal);
         this._deletedList.Remove(hashKey);
-        this._cacheSize += insertedSize;
-        this._recordsBeforeCurrentView = repOfOriginal.RecordsBeforeCurrentView;
-        this._totalRecordsCount = repOfOriginal.TotalRecordsCount;
         return true;
     }
     removeDvFromCache(DvPosValue, updateDel) {
         let rep = this._cacheTable.get_Item(DvPosValue);
         if (rep !== null) {
-            this._cacheSize -= (rep.getSize() * (rep.getCurrRec()).getRecSize());
             if (updateDel)
                 this._deletedList.push(DvPosValue);
             this._cacheTable.Remove(DvPosValue);
@@ -19627,10 +19443,10 @@ class DvCache {
         return false;
     }
     getDeletedListToXML() {
-        let list = "";
+        let list = '';
         for (let i = 0; i < this._deletedList.length; i++) {
             if (i > 0)
-                list = list + ",";
+                list = list + ',';
             list += this._deletedList.get_Item(i).toString();
         }
         return list;
@@ -19644,21 +19460,6 @@ class DvCache {
             cached = cached.replicate();
         return cached;
     }
-    getLastUsedDv() {
-        let currentTimeStamp = Misc.getSystemMilliseconds();
-        let lruDiff = -1;
-        let lruDvPos = -1;
-        let keysList = this._cacheTable.Keys;
-        while (keysList.MoveNext()) {
-            let current = this._cacheTable.get_Item(keysList.Current);
-            let diff = currentTimeStamp - current.getCacheLRU();
-            if (diff > lruDiff) {
-                lruDiff = diff;
-                lruDvPos = current.getDvPosValue();
-            }
-        }
-        return lruDvPos;
-    }
     clearCache() {
         let dvKeysList = new List(this._cacheTable.Keys);
         for (let i = 0; i < dvKeysList.length; i++) {
@@ -21586,7 +21387,6 @@ class MgForm extends MgFormBase {
             if (this.isTableWithAbsoluteScrollbar() && this.GetDataview().TotalRecordsCount > 0) {
                 let recPosOnPage = this.GetDataview().RecordsBeforeCurrentView % this._rowsInPage;
                 if (recPosOnPage > 0 && this.DisplayLine === 0) {
-                    let lastFocusedVal = { guiMgControl: this.getTableCtrl(), Line: recPosOnPage, Val: "" };
                     yield this.setRowData(-recPosOnPage, false);
                 }
             }
@@ -22140,52 +21940,9 @@ class RemoteDataviewHeader extends DataviewHeaderBase {
     }
 }
 
-class DataviewHeaderFactory {
-    CreateDataviewHeaders(task) {
-        return new RemoteDataviewHeader(task);
-    }
-}
-
-class DataviewHeadersSaxHandler {
-    constructor(task, dataviewHeaders, xmlData) {
-        this._dataviewHeaders = null;
-        this._task = null;
-        this._dataviewHeadersFactory = null;
-        this._dataviewHeaders = dataviewHeaders;
-        this._task = task;
-        this._dataviewHeadersFactory = new DataviewHeaderFactory();
-        JSON_Utils.JSONFromXML(xmlData, this.FillFromJSON.bind(this));
-    }
-    FillFromJSON(error, result) {
-        if (error != null) {
-            throw error;
-        }
-        let links = result[ConstInterface.MG_TAG_LINKS][ConstInterface.MG_TAG_LINK];
-        if (!isNullOrUndefined(links) && links.constructor === Array) {
-            for (let i = 0; i < links.length; i++) {
-                let link = links[i]['$'];
-                if (!isNullOrUndefined(link[ConstInterface.MG_ATTR_TABLE_INDEX])) {
-                    let tableIndex = +link[ConstInterface.MG_ATTR_TABLE_INDEX];
-                    let dataviewHeader = this._dataviewHeadersFactory.CreateDataviewHeaders(this._task);
-                    let attributes = new Dictionary();
-                    for (let key in link) {
-                        if (key !== ConstInterface.MG_ATTR_TABLE_INDEX) {
-                            attributes.Add(key, link[key]);
-                        }
-                    }
-                    dataviewHeader.SetAttributes(attributes);
-                    this._dataviewHeaders.set_Item(dataviewHeader.Id, dataviewHeader);
-                }
-            }
-        }
-    }
-}
-
 class DataviewHeaders {
-    constructor(task) {
+    constructor() {
         this._dataviewHeaders = null;
-        this._task = null;
-        this._task = task;
         this._dataviewHeaders = new Hashtable();
     }
     fillData(parser) {
@@ -22199,7 +21956,6 @@ class DataviewHeaders {
             let endContext = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_LINKS_END, parser.getCurrIndex()) + ConstInterface.MG_TAG_LINKS_END.length + 1;
             let xml = parser.getXMLsubstring(endContext);
             xml = XmlParser.escapeUrl(xml);
-            let dataviewHeadersSaxHandler = new DataviewHeadersSaxHandler(this._task, this._dataviewHeaders, xml);
             parser.setCurrIndex(endContext + XMLConstants.TAG_CLOSE.length);
         }
         else
@@ -22737,7 +22493,6 @@ class EventHandler {
                         this._task.leaveLoop();
                         break;
                     case ConstInterface.MG_OPER_BLOCK:
-                        let startBlockIdx = execFlowIdx;
                         if (!oper.getExecOnServer() || (returnedFromServer && oper.getServerId() < nextOperIdx)) {
                             this._task.setUseLoopStack(true);
                             if (!returnedFromServer || oper.getServerId() >= nextOperIdx)
@@ -23583,12 +23338,10 @@ class FormsTable {
 }
 
 class ActionManager {
-    constructor(parent) {
+    constructor() {
         this._actCount = null;
         this._actState = null;
-        this._parentTask = null;
         this._numerator = 0;
-        this._parentTask = parent;
         this._numerator = 0;
         this._actState = new Array(InternalInterface.MG_ACT_TOT_CNT);
         for (let _ai = 0; _ai < this._actState.length; ++_ai)
@@ -23598,7 +23351,6 @@ class ActionManager {
             this._actCount[_ai] = 0;
     }
     enable(act, enable) {
-        let valueChanged = this._actState[act] !== enable;
         this._actState[act] = enable;
         if (enable) {
             this._numerator++;
@@ -23727,14 +23479,6 @@ var Task_Direction;
     Task_Direction[Task_Direction["NONE"] = 0] = "NONE";
     Task_Direction[Task_Direction["FORE"] = 1] = "FORE";
 })(Task_Direction || (Task_Direction = {}));
-var FlowModeDir;
-(function (FlowModeDir) {
-    FlowModeDir["NONE"] = " ";
-    FlowModeDir["FAST_BACKWARD"] = "R";
-    FlowModeDir["FAST_FORWARD"] = "F";
-    FlowModeDir["STEP_BACKWARD"] = "P";
-    FlowModeDir["STEP_FORWARD"] = "N";
-})(FlowModeDir || (FlowModeDir = {}));
 class Task extends TaskBase {
     constructor(parent) {
         super();
@@ -23846,7 +23590,7 @@ class Task extends TaskBase {
         return false;
     }
     constructor_0() {
-        this.ActionManager = new ActionManager(this);
+        this.ActionManager = new ActionManager();
         this.DataView = new DataView(this);
         this._flowMonitor = FlowMonitorQueue.Instance;
         this.ContextTask = this;
@@ -24025,7 +23769,6 @@ class Task extends TaskBase {
                 case XMLConstants.MG_ATTR_MENU_CONTENT:
                     break;
                 case "assemblies":
-                    let start = parser.getCurrIndex();
                     let endContext = parser.getXMLdata().indexOf('/assemblies', parser.getCurrIndex());
                     parser.setCurrIndex(endContext);
                     parser.setCurrIndex2EndOfTag();
@@ -24062,7 +23805,7 @@ class Task extends TaskBase {
                     this.UserEvtTab.fillData(this, parser);
                     break;
                 case ConstInterface.MG_TAG_LINKS:
-                    this.DataviewHeadersTable = new DataviewHeaders(this);
+                    this.DataviewHeadersTable = new DataviewHeaders();
                     this.DataviewHeadersTable.fillData(parser);
                     break;
                 case ConstInterface.MG_TAG_SORTS:
@@ -24458,7 +24201,6 @@ class Task extends TaskBase {
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             let task;
-            let form = this.getForm();
             if (this._aborting)
                 return;
             if (this.hasSubTasks()) {
@@ -25160,7 +24902,6 @@ class Task extends TaskBase {
         });
     }
     SetServerSideTaskSuffix(task) {
-        let clientOperationExist = false;
         var rtEvt = new RunTimeEvent(task);
         rtEvt.setInternal(InternalInterface.MG_ACT_TASK_SUFFIX);
         let handler = null;
@@ -26201,7 +25942,6 @@ class Task extends TaskBase {
     static OpenForms(callByDestSubForm) {
         return __awaiter(this, void 0, void 0, function* () {
             let createdForms = MgForm.CreatedForms;
-            let outMostForm = null;
             if (createdForms.Count() > 0) {
                 let i = 0;
                 while (i < createdForms.Count()) {
@@ -26223,8 +25963,6 @@ class Task extends TaskBase {
                         yield Manager.DoFirstRefreshTable(mgForm);
                     }
                     if (mgForm.Opened) {
-                        if (callByDestSubForm && mgForm.isSubForm())
-                            outMostForm = mgForm.getTopMostForm();
                         createdForms.remove(mgForm);
                     }
                     else
@@ -26966,13 +26704,11 @@ class EventsManager {
         this._stopExecution = false;
         this._processingTopMostEndTask = false;
         this._stopExecutionCtrl = null;
-        this._isSorting = false;
-        this._nextParkedCtrl = null;
         this.guiPendingEvent = null;
         this.KBI_DOWN = null;
         this.KBI_UP = null;
-        this.confirmationDialogMsg = "The server context serving this application is about to time out. Do you want to continue your work?";
-        this.confirmationDialogTitle = "Session is about to be terminated!";
+        this.confirmationDialogMsg = 'The server context serving this application is about to time out. Do you want to continue your work?';
+        this.confirmationDialogTitle = 'Session is about to be terminated!';
         this._lastFailedFocusedControl = null;
         this.isSpinnerShown = false;
         this.SpinnerStopped = new Subject();
@@ -26982,7 +26718,6 @@ class EventsManager {
         this._execStack.push(new ExecutionStack());
         this._serverExecStack = new Stack();
         this._serverExecStack.push(null);
-        this._nextParkedCtrl = null;
         this.KBI_DOWN = new KeyboardItem(GuiConstants.KEY_DOWN, Modifiers.MODIFIER_NONE);
         this.KBI_UP = new KeyboardItem(GuiConstants.KEY_UP, Modifiers.MODIFIER_NONE);
     }
@@ -27335,7 +27070,7 @@ class EventsManager {
         let argsList = new Array(2);
         argsList[0] = new ExpVal(StorageAttribute.ALPHA, false, routerpath);
         if (routerOutletName === null)
-            routerOutletName = "";
+            routerOutletName = '';
         argsList[1] = new ExpVal(StorageAttribute.ALPHA, false, routerOutletName);
         let args = new ArgumentsList(argsList);
         rtEvt.setArgList(args);
@@ -27419,7 +27154,6 @@ class EventsManager {
     ExecuteClientContextInactivityTimer() {
         return __awaiter(this, void 0, void 0, function* () {
             let startTime = Misc.getSystemMilliseconds();
-            let currTime;
             let clientCtxInactivityTimeout = Environment.Instance.getClientContextInactivityTimeout() * 100;
             EventsManager.clientInactivityTimerON = true;
             while (EventsManager.clientInactivityTimerON) {
@@ -27562,7 +27296,6 @@ class EventsManager {
                 if (task !== null)
                     yield Task.CommandsProcessor.SendMonitorOnly();
                 else {
-                    let mainProg = MGDataCollection.Instance.GetMainProgByCtlIdx(0);
                     yield Task.CommandsProcessor.SendMonitorOnly();
                 }
                 if (rtEvt !== null && rtEvt.isGuiTriggeredEvent()) {
@@ -27660,7 +27393,6 @@ class EventsManager {
                 let evtCtrl = rtEvt.Control;
                 if (evtCtrl !== null && evtCtrl.getField() !== null) {
                     let ctrlVal = Manager.GetCtrlVal(evtCtrl);
-                    let evtCtrlval = evtCtrl.Value;
                     yield evtCtrl.validateAndSetValue(ctrlVal, true);
                 }
             }
@@ -27714,7 +27446,6 @@ class EventsManager {
         return __awaiter(this, void 0, void 0, function* () {
             let kbdItem = evt.getKbdItmAlways();
             let keyCode = kbdItem.getKeyCode();
-            let modifier = kbdItem.getModifier();
             this._currKbdItem = kbdItem;
             if (evt.IgnoreSpecifiedControl) {
                 ctrl = this.getCurrCtrl();
@@ -27722,7 +27453,7 @@ class EventsManager {
                 if (ctrl.Type !== MgControlType.CTRL_TYPE_TEXT)
                     return;
             }
-            Logger.Instance.WriteDevToLog("Start handling KEYDOWN event. Key code: " + keyCode);
+            Logger.Instance.WriteDevToLog('Start handling KEYDOWN event. Key code: ' + keyCode);
             try {
                 if (this._currKbdItem.equals(this.KBI_DOWN) || this._currKbdItem.equals(this.KBI_UP)) {
                     if (ctrl !== null && (ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO))
@@ -27744,7 +27475,7 @@ class EventsManager {
                 let mgd = MGDataCollection.Instance.getCurrMGData();
                 if (mgd !== null && !mgd.IsAborting)
                     yield this.handleExpressionHandlers();
-                Logger.Instance.WriteDevToLog("End handling KEYDOWN event. Key code: " + keyCode);
+                Logger.Instance.WriteDevToLog('End handling KEYDOWN event. Key code: ' + keyCode);
                 if (ctrl !== null && ctrl.IsRepeatable && ctrl === MgControl.ReturnToCtrl) {
                     yield ctrl.getForm().bringRecordToPage();
                 }
@@ -27823,7 +27554,7 @@ class EventsManager {
                     return;
                 if (ctrl !== this._lastFailedFocusedControl && ctrl.HasExpOrParentTaskField()) {
                     if (ctrl.isListBox() || ctrl.isCheckBox() || ctrl.isComboBox() || ctrl.isTextControl() || ctrl.isRadio() || ctrl.isTabControl()) {
-                        Logger.Instance.WriteErrorToLog(NString.Format("Control either has expression or has parent task variable attached to it. Failed to park on control with name: {0}", ctrl.Name));
+                        Logger.Instance.WriteErrorToLog(NString.Format('Control either has expression or has parent task variable attached to it. Failed to park on control with name: {0}', ctrl.Name));
                         FocusManager.SetFocus(LastFocusedManager.Instance.getLastFocusedTask(), LastFocusedManager.getLastFocusedControl(), 0, LastFocusedManager.getLastFocusedControl() === null ? true : false);
                         this._lastFailedFocusedControl = ctrl;
                         return;
@@ -27838,7 +27569,6 @@ class EventsManager {
                     return;
                 }
                 let prevTask = LastFocusedManager.Instance.getLastFocusedTask();
-                this._nextParkedCtrl = ctrl;
                 if (ctrl === null || ctrl.Type === MgControlType.CTRL_TYPE_TABLE) {
                     if (prevCtrl === null)
                         yield this.HandleNonParkableControls(ctrl.getForm().getTask());
@@ -28096,7 +27826,7 @@ class EventsManager {
                     yield this.HandleNonParkableControls(ctrl.getForm().getTask());
                 return false;
             }
-            Logger.Instance.WriteSupportToLog(NString.Format("{0} Entering control: control {1}, row {2}", task.GetTaskDetails(), ctrl.Name, displayLine < 0 ? 0 : displayLine), true);
+            Logger.Instance.WriteSupportToLog(NString.Format('{0} Entering control: control {1}, row {2}', task.GetTaskDetails(), ctrl.Name, displayLine < 0 ? 0 : displayLine), true);
             task.setLevel(Constants.TASK_LEVEL_CONTROL);
             ctrl.KeyStrokeOn = false;
             ctrl.ModifiedByUser = false;
@@ -28282,11 +28012,11 @@ class EventsManager {
                                 }
                             }
                             else
-                                throw new ApplicationException("in EventsManager.commonHandlerBefore(): invalid line number: " +
+                                throw new ApplicationException('in EventsManager.commonHandlerBefore(): invalid line number: ' +
                                     displayLine);
                         }
                         if (rec == null)
-                            throw new ApplicationException("in EventsManager.commonHandlerBefore(): no current record available !");
+                            throw new ApplicationException('in EventsManager.commonHandlerBefore(): no current record available !');
                         if (!task.IsInteractive && task.getLevel() === Constants.TASK_LEVEL_TASK)
                             task.increaseCounter();
                         if (yield task.evalEndCond(ConstInterface.END_COND_EVAL_BEFORE)) {
@@ -28298,7 +28028,7 @@ class EventsManager {
                         if (task.getLevel() !== Constants.TASK_LEVEL_TASK)
                             return false;
                         yield form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
-                        Logger.Instance.WriteDevToLog("RECORD PREFIX: " + task.queryTaskPath());
+                        Logger.Instance.WriteDevToLog('RECORD PREFIX: ' + task.queryTaskPath());
                         (dv.getCurrRec()).setForceSaveOrg(false);
                         (dv.getCurrRec()).Synced = false;
                         dv.saveOriginal();
@@ -28344,7 +28074,7 @@ class EventsManager {
                         yield task.handleEventOnSlaveTasks(InternalInterface.MG_ACT_REC_SUFFIX);
                         if (this._stopExecution)
                             return false;
-                        Logger.Instance.WriteDevToLog("RECORD SUFFIX: " + task.queryTaskPath());
+                        Logger.Instance.WriteDevToLog('RECORD SUFFIX: ' + task.queryTaskPath());
                         task.setLevel(Constants.TASK_LEVEL_TASK);
                         isSelectionTable = yield task.checkProp(PropInterface.PROP_TYPE_SELECTION, false);
                         if (task.getMode() === Constants.TASK_MODE_QUERY && !forceSuffix && !rec.Modified &&
@@ -28383,7 +28113,7 @@ class EventsManager {
                             val = Manager.GetCtrlVal(ctrl);
                             task.CurrentEditingControl = null;
                             if (!task.cancelWasRaised() &&
-                                (ctrl.Type !== MgControlType.CTRL_TYPE_BROWSER && (!isNullOrUndefined(ctrl._field) && ctrl._field.getType() === StorageAttribute.DATE || val !== null) && typeof val != "undefined" &&
+                                (ctrl.Type !== MgControlType.CTRL_TYPE_BROWSER && (!isNullOrUndefined(ctrl._field) && ctrl._field.getType() === StorageAttribute.DATE || val !== null) && typeof val != 'undefined' &&
                                     !(yield ctrl.validateAndSetValue(val, true)))) {
                                 this.setStopExecution(true);
                                 return false;
@@ -28506,16 +28236,6 @@ class EventsManager {
             }
         });
     }
-    moveToLine(form, displayLine, ctrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let runTimeEvent = new RunTimeEvent(ctrl, displayLine);
-            runTimeEvent.setInternal(InternalInterface.MG_ACT_REC_PREFIX);
-            yield this.handleEvent(runTimeEvent, false);
-            if (ctrl !== null)
-                yield ctrl.invoke();
-            form.SelectRow(true);
-        });
-    }
     createEventArguments(evt) {
         if (evt.getArgList() === null) {
             if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {
@@ -28717,8 +28437,6 @@ class EventsManager {
                                     return;
                                 doSuffix = refDoSuffix.value;
                                 if (form != null) {
-                                    let parentId = 0;
-                                    let prevLine = 0;
                                     if ((task.getMode() !== Constants.TASK_MODE_CREATE) || !task.ConfirmUpdateNo)
                                         yield form.addRec(doSuffix, intEvtCode == InternalInterface.MG_ACT_CRELINE_ABOVE ? true : false);
                                 }
@@ -28951,7 +28669,6 @@ class EventsManager {
                                     yield task.DataviewManager.Execute(cmd);
                                     dv.setTopRecIdx(0);
                                     yield form.restoreOldDisplayLine(0);
-                                    this._isSorting = true;
                                     if (!(task === LastFocusedManager.Instance.getLastFocusedTask() || !task.pathContains(LastFocusedManager.Instance.getLastFocusedTask()))) {
                                         yield this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
                                         if (!this.GetStopExecutionFlag() && !task.getPreventControlChange())
@@ -28961,7 +28678,6 @@ class EventsManager {
                                     }
                                     else
                                         yield this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
-                                    this._isSorting = false;
                                 }
                             }
                             break;
@@ -29209,7 +28925,7 @@ class EventsManager {
                             if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_RECORD && evt.getArgList() !== null && evt.getArgList().getSize() !== 0) {
                                 let refetchRecStr;
                                 refetchRecStr = yield evt.getArgList().getArgValue(0, StorageAttribute.BOOLEAN, 0);
-                                refetchRecord = (isNullOrUndefined(refetchRecStr) || refetchRecStr === "1");
+                                refetchRecord = (isNullOrUndefined(refetchRecStr) || refetchRecStr === '1');
                             }
                             if (refetchRecord)
                                 cmd = yield CommandFactory.CreateRealRefreshCommand(task.getTaskTag(), intEvtCode, currentRow, evt.getArgList(), dv.CurrentRecId);
@@ -29402,7 +29118,6 @@ class EventsManager {
                                 ctrl.InControl = true;
                                 return;
                             }
-                            this._nextParkedCtrl = null;
                             let fld = ctrl.getField();
                             if (fld != null && (ctrl.Type === MgControlType.CTRL_TYPE_TEXT))
                                 yield fld.updateDisplay();
@@ -29612,7 +29327,7 @@ class EventsManager {
                     yield FocusManager.SetFocus(LastFocusedManager.getLastFocusedControl(), -1);
                     return false;
                 default:
-                    Logger.Instance.WriteExceptionToLogWithMsg("in ClientManager.Instance.updateConfirmed() illegal confirmation code: " +
+                    Logger.Instance.WriteExceptionToLogWithMsg('in ClientManager.Instance.updateConfirmed() illegal confirmation code: ' +
                         confirm);
                     break;
             }
@@ -29646,7 +29361,7 @@ class EventsManager {
         let dataStorage = window.localStorage;
         if (this.getLastSavedRouteEvent() != null) {
             let rtEvt = this.getLastSavedRouteEvent();
-            dataStorage.setItem(ConstInterface.LAST_ROUTE_EVENT, "1");
+            dataStorage.setItem(ConstInterface.LAST_ROUTE_EVENT, '1');
             dataStorage.setItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK, JSON.stringify(rtEvt.getTask().TaskDefinitionId));
             if (rtEvt.getArgList().getSize() > 0) {
                 let str = new StringBuilder();
@@ -29658,7 +29373,7 @@ class EventsManager {
     restoreLastSavedRouteEventFromLocalStorage() {
         let dataStorage = window.localStorage;
         let lastRouteEvent = dataStorage.getItem(ConstInterface.LAST_ROUTE_EVENT);
-        if (lastRouteEvent === "1") {
+        if (lastRouteEvent === '1') {
             let srcTaskDefinitionStr = dataStorage.getItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK);
             let routeArgListStr = dataStorage.getItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST);
             let taskDefinitionId = new TaskDefinitionId();
@@ -29925,7 +29640,7 @@ class EventsManager {
                 ((parentDv.getCurrRec())).Synced = true;
                 parentDv.setChanged(true);
                 let dataViewExecuteLocalUpdatesCommand = CommandFactory.CreateDataViewCommand(parentTask.getTaskTag(), DataViewCommandType.ExecuteLocalUpdates);
-                let result = yield parentTask.DataviewManager.Execute(dataViewExecuteLocalUpdatesCommand);
+                yield parentTask.DataviewManager.Execute(dataViewExecuteLocalUpdatesCommand);
             }
         });
     }
@@ -29951,7 +29666,7 @@ class EventsManager {
             MGDataCollection.Instance.currMgdID = 0;
             let messageString = LanguageData.Instance.getConstMessage(MsgInterface.BRKTAB_STR_ERROR);
             let style = 16;
-            if (ex.Message.startsWith("<HTML")) {
+            if (ex.Message.startsWith('<HTML')) {
                 this.processHTMLContent(ex.Message);
             }
             else {
@@ -30004,7 +29719,6 @@ class EventsManager {
         return true;
     }
 }
-EventsManager.Timer_Timeout_Infinite = -1;
 EventsManager.REAL_ONLY = true;
 EventsManager.MAX_OPER = 9999;
 EventsManager.userGrantedForContextActivity = true;
@@ -30108,13 +29822,6 @@ class GuiEventsProcessor extends EventsProcessor {
             EventsManager.Instance.addToTail(rtEvt);
         }
     }
-    static processEnableActs(guiMgCtrl, actList, enable) {
-        let mgControl = guiMgCtrl;
-        let rtEvt = new RunTimeEvent(mgControl, true);
-        rtEvt.setInternal(enable ? InternalInterface.MG_ACT_ENABLE_EVENTS : InternalInterface.MG_ACT_DISABLE_EVENTS);
-        rtEvt.setActEnableList(actList);
-        EventsManager.Instance.addToTail(rtEvt);
-    }
     static OnNonParkableLastParkedCtrl(ctrl) {
     }
     static processSelection(val, guiMgCtrl, line, produceClick) {
@@ -30154,16 +29861,6 @@ class GuiEventsProcessor extends EventsProcessor {
     static SaveLastClickInfo(controlName, X, Y, offsetX, offsetY, LastClickCoordinatesAreInPixels) {
         RuntimeContextBase.Instance.SaveLastClickInfo(controlName, X, Y, offsetX, offsetY, LastClickCoordinatesAreInPixels);
     }
-    static ProcessPress(guiMgForm, guiMgCtrl, line) {
-        let mgControl = guiMgCtrl;
-        if (mgControl == null)
-            Manager.EventsManager.addGuiTriggeredEventWithTaskAndCode(guiMgForm.getTask(), InternalInterface.MG_ACT_HIT);
-        else if (mgControl.isSubform())
-            mgControl.OnSubformClick();
-        else
-            Manager.EventsManager.addGuiTriggeredEventWithCtrlAndCodeAndLine(mgControl, InternalInterface.MG_ACT_CTRL_HIT, line);
-        Manager.EventsManager.addGuiTriggeredEventWithCtrlAndCodeAndLine(mgControl, InternalInterface.MG_ACT_PRESS, line);
-    }
     static IsLogonRTL() {
         return ServerConfig.Instance.IsLogonRTL();
     }
@@ -30217,7 +29914,6 @@ class OpenURLCommand extends ClientTargetedCommandBase {
             let guiParentMgData = null;
             let callingTask = (this._callingTaskTag != null ? AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag) : null);
             let pathParentTask = (this._pathParentTaskTag != null ? AccessHelper.mgDataTable.GetTaskByID(this._pathParentTaskTag) : null);
-            let lastFocusedTask = LastFocusedManager.Instance.getLastFocusedTask();
             guiParentTask = callingTask = AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag);
             if ((!NString.IsNullOrEmpty(this._subformCtrlName)) || (this._ditIdx !== Int32.MinValue) || this._isRoute) {
                 if (this._isRoute && NString.IsNullOrEmpty(this._subformCtrlName.trim())) {
@@ -30477,7 +30173,6 @@ class VerifyCommand extends ClientTargetedCommandBase {
         this._text = null;
         this._display = '\0';
         this._mode = '\0';
-        this._sendAck = true;
     }
     Execute(res) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -30536,7 +30231,6 @@ class VerifyCommand extends ClientTargetedCommandBase {
                 this._mode = value[0];
                 break;
             case ConstInterface.MG_ATTR_ACK:
-                this._sendAck = (XmlParser.getInt(value) !== 0);
                 break;
             default:
                 super.HandleAttribute(attribute, value);
@@ -31021,7 +30715,7 @@ class CommandsTable {
         startIterationIdx = this._iterationIdx;
         for (; this._iterationIdx < size; this._iterationIdx++) {
             cmd = ((this.getCmd(this._iterationIdx) instanceof AbortCommand) ? this.getCmd(this._iterationIdx) : null);
-            if (cmd != null && !cmd.TaskTag.startsWith("-") && cmd.Frame === frame) {
+            if (cmd != null && !cmd.TaskTag.startsWith('-') && cmd.Frame === frame) {
                 for (verifyIndex = 0; verifyIndex < this._iterationIdx; verifyIndex++) {
                     verifyCmd = ((this.getCmd(verifyIndex) instanceof VerifyCommand) ? this.getCmd(verifyIndex) : null);
                     if (verifyCmd != null && verifyCmd.Frame === frame) {
@@ -31069,7 +30763,6 @@ class CommandsTable {
     buildXML(message) {
         for (let i = 0; i < this._cmds.length; i = i + 1) {
             let cmd = this._cmds.get_Item(i);
-            let temp = new RefParam(false);
             message.Append(ClientOriginatedCommandSerializer.Serialize(cmd, AccessHelper.mgDataTable.getCurrMGData()));
         }
         this.clear();
@@ -31093,12 +30786,10 @@ class CommandsTable {
     }
 }
 
-let CurrentClientVersion = '4.801.0-dev481.306';
+let CurrentClientVersion = '4.801.0-dev481.309';
 
 class ClientManager {
     constructor() {
-        this._guiEventsProcessor = null;
-        this._tableCacheManager = null;
         this._delayInProgress = false;
         this._debugClient = null;
         this._globalUniqueSessionId = null;
@@ -31118,7 +30809,6 @@ class ClientManager {
     AddEvent(guiEvent) {
         let task = MGDataCollection.Instance.GetTaskByID(guiEvent.TaskID);
         let lineIdx = +guiEvent.Line;
-        let clickDblClickSucceeded = false;
         let dvRowIdx = 0;
         if (task != null) {
             let control = null;
@@ -31319,7 +31009,7 @@ class ClientManager {
             HttpManager.setNativeHttpClient(httpClient);
             let loaded = yield ClientManager.Instance.LoadExecutionProps();
             if (loaded) {
-                ClientManager.Instance._guiEventsProcessor = new GuiEventsProcessor();
+                new GuiEventsProcessor();
                 ClientManager.Instance.InitGuiManager();
                 ClientManager.Instance.InitCircularReferencesBypasses();
                 let versionString = CurrentClientVersion === '0.0.0.0' ? "Development mode" : "Version : " + CurrentClientVersion;
@@ -31391,11 +31081,6 @@ class ClientManager {
     GetGlobalUniqueSessionID() {
         return this._globalUniqueSessionId;
     }
-    static getExecutionPropertiesFileName() {
-        let fullyQualifiedName = null;
-        let lastPathSeparator = fullyQualifiedName.lastIndexOf('\\');
-        return NString.Remove(fullyQualifiedName, lastPathSeparator + 1, fullyQualifiedName.length - lastPathSeparator - 1) + ConstInterface.EXECUTION_PROPERTIES_FILE_NAME;
-    }
     static GetControlPictureMask(taskId, controlName) {
         let pic = null;
         let task = MGDataCollection.Instance.GetTaskByID(taskId);
@@ -31538,15 +31223,47 @@ class MagicBridge {
 }
 
 class DataSourceIdKey {
-    constructor(taskCtlIdx, realIdx) {
-        this.taskCtlIdx = 0;
-        this.realIdx = 0;
-        this.taskCtlIdx = taskCtlIdx;
-        this.realIdx = realIdx;
+}
+
+class DataviewHeaderFactory {
+    CreateDataviewHeaders(task) {
+        return new RemoteDataviewHeader(task);
     }
-}
-DataSourceIdKey.PRIME_NUMBER = 37;
-DataSourceIdKey.SEED = 23;
+}
+
+class DataviewHeadersSaxHandler {
+    constructor(task, dataviewHeaders, xmlData) {
+        this._dataviewHeaders = null;
+        this._task = null;
+        this._dataviewHeadersFactory = null;
+        this._dataviewHeaders = dataviewHeaders;
+        this._task = task;
+        this._dataviewHeadersFactory = new DataviewHeaderFactory();
+        JSON_Utils.JSONFromXML(xmlData, this.FillFromJSON.bind(this));
+    }
+    FillFromJSON(error, result) {
+        if (error != null) {
+            throw error;
+        }
+        let links = result[ConstInterface.MG_TAG_LINKS][ConstInterface.MG_TAG_LINK];
+        if (!isNullOrUndefined(links) && links.constructor === Array) {
+            for (let i = 0; i < links.length; i++) {
+                let link = links[i]['$'];
+                if (!isNullOrUndefined(link[ConstInterface.MG_ATTR_TABLE_INDEX])) {
+                    let dataviewHeader = this._dataviewHeadersFactory.CreateDataviewHeaders(this._task);
+                    let attributes = new Dictionary();
+                    for (let key in link) {
+                        if (key !== ConstInterface.MG_ATTR_TABLE_INDEX) {
+                            attributes.Add(key, link[key]);
+                        }
+                    }
+                    dataviewHeader.SetAttributes(attributes);
+                    this._dataviewHeaders.set_Item(dataviewHeader.Id, dataviewHeader);
+                }
+            }
+        }
+    }
+}
 
 class MenusDeserializer {
 }