@magic-xpa/engine 4.1100.0-dev4110.19 → 4.1100.0-dev4110.190

package/esm2022/src/event/EventsManager.mjs

@@ -0,0 +1,2975 @@
+import { Constants, ForceExit, InternalInterface, Logger, Logger_LogLevels, MgControlType, Misc, MsgInterface, Priority, RaiseAt, StorageAttribute, StrUtil, SubformType } from '@magic-xpa/utils';
+import { ApplicationException, Int32, List, NString, RefParam, Stack, StringBuilder, Thread, isNullOrUndefined } from '@magic-xpa/mscorelib';
+import { Commands, CommandType, DataModificationTypes, ExpVal, FocusManager, GuiConstants, GuiEnvironment, KeyboardItem, Manager, Modifiers, PropInterface, RuntimeContextBase, Styles, TaskDefinitionId } from '@magic-xpa/gui';
+import { EventSubType } from '../enums';
+import { RollbackEventCommand_RollbackType } from '../commands/ClientToServer/RollbackEventCommand';
+import { MgControl } from '../gui/MgControl';
+import { MgPriorityBlockingQueue } from '../util/MgPriorityBlockingQueue';
+import { RunTimeEvent } from './RunTimeEvent';
+import { FlowMonitorQueue } from '../util/FlowMonitorQueue';
+import { GUIManager } from '../GUIManager';
+import { Task } from '../tasks/Task';
+import { Task_SubformExecModeEnum } from '../tasks/TaskBase';
+import { ArgumentsList } from '../rt/ArgumentsList';
+import { MGData } from '../tasks/MGData';
+import { MGDataCollection } from '../tasks/MGDataCollection';
+import { RecordOutOfDataViewException } from '../data/RecordOutOfDataViewException';
+import { CommandsProcessorBase_SendingInstruction } from '../CommandsProcessorBase';
+import { CommandFactory } from '../commands/ClientToServer/CommandFactory';
+import { CommandsProcessorManager } from '../CommandsProcessorManager';
+import { ClientRefreshCommand } from '../commands/ServerToClient/ClientRefreshCommand';
+import { RemoteCommandsProcessor } from '../remote/RemoteCommandsProcessor';
+import { ExecutionStack } from '../rt/ExecutionStack';
+import { EventHandlerPosition } from './EventHandlerPosition';
+import { ConstInterface } from '../ConstInterface';
+import { FlowMonitorInterface } from '../FlowMonitorInterface';
+import { DataViewCommandType } from '../commands/ClientToServer/DataviewCommand';
+import { ServerError } from '../remote/ServerError';
+import { Environment } from '../env/Environment';
+import { LastFocusedManager } from '../rt/LastFocusedManager';
+import { EventsAllowedType } from './IEventsManager';
+import { LanguageData } from '../env/LanguageData';
+import { Subject } from 'rxjs';
+import { ClientManager } from '../ClientManager';
+import { ClearEventsOnStopExecution } from '../AccessHelper';
+var EventScope;
+(function (EventScope) {
+    EventScope["NONE"] = " ";
+    EventScope["TRANS"] = "T";
+})(EventScope || (EventScope = {}));
+export class EventsManager {
+    static REAL_ONLY = true;
+    static MAX_OPER = 9999;
+    static userGrantedForContextActivity = true;
+    _eventsQueue = null;
+    _execStack = null;
+    _rtEvents = null;
+    _serverExecStack = null;
+    _allowEvents = EventsAllowedType.ALL;
+    _compMainPrgTab = null;
+    _currCtrl = null;
+    _currField = null;
+    _currKbdItem = null;
+    _endOfWork = false;
+    _eventScope = EventScope.NONE;
+    _forceExit = ForceExit.None;
+    _forceExitTask = null;
+    _ignoreUnknownAbort = false;
+    _initialized = false;
+    _isHandlingForceExit = false;
+    _isNonReversibleExit = false;
+    _isInRecordFlushEvent = false;
+    static clientInactivityTimerON = false;
+    static clientContextInactivityTimerAborted = false;
+    lastSavedRouteEvent = null;
+    _stopExecution = false;
+    _processingTopMostEndTask = false;
+    _stopExecutionCtrl = null;
+    guiPendingEvent = null;
+    KBI_DOWN = null;
+    KBI_UP = null;
+    confirmationDialogMsg = 'The server context serving this application is about to time out. Do you want to continue your work?';
+    confirmationDialogTitle = 'Session is about to be terminated!';
+    static Instance = new EventsManager();
+    _lastFailedFocusedControl = null;
+    isSpinnerShown = false;
+    isInViewRefresh = false;
+    SpinnerStopped = new Subject();
+    static clientBusyTimeStart = 0;
+    constructor() {
+        this._rtEvents = new Stack();
+        this._eventsQueue = new MgPriorityBlockingQueue();
+        this._execStack = new Stack();
+        this._execStack.push(new ExecutionStack());
+        this._serverExecStack = new Stack();
+        this._serverExecStack.push(null);
+        this.KBI_DOWN = new KeyboardItem(GuiConstants.KEY_DOWN, Modifiers.MODIFIER_NONE);
+        this.KBI_UP = new KeyboardItem(GuiConstants.KEY_UP, Modifiers.MODIFIER_NONE);
+    }
+    getPendingGuiEvent() {
+        return this.guiPendingEvent;
+    }
+    setPendingGuiEvent(guiEvent) {
+        this.guiPendingEvent = guiEvent;
+    }
+    addToTail(rtEvt) {
+        if (!rtEvt.isIdleTimer()) {
+            if (EventsManager.clientInactivityTimerON) {
+                EventsManager.clientContextInactivityTimerAborted = true;
+            }
+        }
+        else {
+            if (this.getLastSavedRouteEvent() != null) {
+                this.addToTail(this.getLastSavedRouteEvent());
+                this.setLastSavedRouteEvent(null);
+            }
+        }
+        this._eventsQueue.put(rtEvt);
+    }
+    AddKeyboardEvent(mgForm, mgControl, modifier, keyCode, start, end, text, isActChar, suggestedValue, code) {
+        let rtEvt = (mgControl !== null) ? new RunTimeEvent(mgControl, true, false) : new RunTimeEvent(mgForm.getTask(), true);
+        rtEvt.setInternal(code);
+        let newKbItem = new KeyboardItem(keyCode, modifier);
+        if (isActChar && (mgControl !== null && (mgControl.isTextControl())))
+            newKbItem.setAction(InternalInterface.MG_ACT_CHAR);
+        rtEvt.setKeyboardItem(newKbItem);
+        if (code === InternalInterface.MG_ACT_CTRL_KEYDOWN) {
+            rtEvt.setEditParms(start, end, text);
+        }
+        else
+            rtEvt.setValue(suggestedValue);
+        this.addToTail(rtEvt);
+        return;
+    }
+    async checkParkability() {
+        let current = LastFocusedManager.getLastFocusedControl();
+        if (current !== null && (current.getForm().getTask()).getLevel() === Constants.TASK_LEVEL_CONTROL && !await current.IsParkable())
+            await this.HandleNonParkableControls(current.getForm().getTask());
+    }
+    async HandleParkabilityOnRowChange(itask) {
+        await this.HandleNonParkableControls(itask);
+    }
+    async HandleNonParkableControls(itask) {
+        let task = itask;
+        if (task.getMode() === Constants.TASK_MODE_CREATE && task.IsInteractive) {
+            await task.enableModes();
+            let oldMode = task.getOriginalTaskMode();
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+            if (!this.GetStopExecutionFlag()) {
+                if (oldMode !== Constants.TASK_MODE_CREATE) {
+                    task.setMode(oldMode);
+                    await task.DataView.currRecCompute(true);
+                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                    await task.getForm().RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                    task.setLastParkedCtrl(null);
+                    await FocusManager.SetFocus(task, null, -1, true);
+                    return;
+                }
+            }
+        }
+        if (task.getLevel() === Constants.TASK_LEVEL_CONTROL)
+            await this.handleInternalEventWithMgControlBase(task.getLastParkedCtrl(), InternalInterface.MG_ACT_CTRL_SUFFIX);
+        task.setLastParkedCtrl(null);
+        MgControl.ReturnToCtrl = null;
+        await FocusManager.SetFocus(task, null, -1, true);
+    }
+    async handleEvent(rtEvt, returnedFromServer) {
+        let handler = null;
+        let pos = new EventHandlerPosition();
+        let task = rtEvt.getTask();
+        let ctrl = task.getLastParkedCtrl();
+        let forceExitDone = false;
+        let endTaskError = false;
+        let oldRtEvt = null;
+        let oldForceExit = this.getForceExit();
+        let oldForceExitTask = this.getForceExitTask();
+        let oldIsHandlingForceExit = this._isHandlingForceExit;
+        let restoreIsForceExit = false;
+        let restoreCurrCtrl;
+        let restoreCurrField = null;
+        if ((rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL)) {
+            if (rtEvt.InternalEvent < InternalInterface.MG_ACT_TOT_CNT && (!task.ActionManager.isEnabled(rtEvt.InternalEvent) || (!rtEvt.isImmediate() && this.NoEventsAllowed())))
+                return;
+        }
+        else if (!rtEvt.isImmediate() && this.NoEventsAllowed())
+            return;
+        restoreCurrCtrl = this._currCtrl;
+        this._currCtrl = ctrl;
+        let propagate = rtEvt.getType() !== ConstInterface.EVENT_TYPE_INTERNAL || rtEvt.getInternalCode() < 1000;
+        try {
+            this.pushRtEvent(rtEvt);
+            await this.CheckAndShowSpinner(true);
+            let bRcBefore = await this.commonHandlerBefore(rtEvt);
+            restoreCurrField = this._currField;
+            this._currField = task.getCurrField();
+            if (bRcBefore) {
+                pos.init(rtEvt);
+                handler = pos.getNext();
+                if (handler !== null && handler.getEvent() !== null && handler.getEvent().UserEvt !== null)
+                    this.setForceExit(handler.getEvent().UserEvt.ForceExit, task);
+                while (handler !== null) {
+                    let handlerContextTask = null;
+                    let rtEvtChanged;
+                    try {
+                        let enabledCndCheckedAndTrue = false;
+                        handlerContextTask = handler.getTask().GetContextTask();
+                        if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() >= 1000 && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_VARIABLE)
+                            handler.getTask().SetContextTask(handler.getTask());
+                        else
+                            handler.getTask().SetContextTask(rtEvt.getTask());
+                        if (handler.getEvent().getType() === ConstInterface.EVENT_TYPE_USER && await handler.isEnabled()) {
+                            enabledCndCheckedAndTrue = true;
+                            this._isHandlingForceExit = false;
+                            restoreIsForceExit = true;
+                            if (await this.handleForceExitBefore(handler.getEvent(), rtEvt)) {
+                                forceExitDone = true;
+                            }
+                        }
+                        if (rtEvt !== handler.getEvent()) {
+                            oldRtEvt = rtEvt;
+                            rtEvt = new RunTimeEvent(handler.getEvent(), rtEvt);
+                            rtEvtChanged = true;
+                            this.popRtEvent();
+                            this.pushRtEvent(rtEvt);
+                        }
+                        else
+                            rtEvtChanged = false;
+                        if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_REC_SUFFIX)
+                            rtEvt.getTask().setInRecordSuffix(true);
+                        this.createEventArguments(rtEvt);
+                        let handlerRetVals = await handler.execute(rtEvt, returnedFromServer, enabledCndCheckedAndTrue);
+                        if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_REC_SUFFIX)
+                            rtEvt.getTask().setInRecordSuffix(false);
+                        propagate = handlerRetVals.Propagate;
+                        if (!handlerRetVals.Enabled && rtEvtChanged) {
+                            rtEvt = oldRtEvt;
+                            oldRtEvt = null;
+                            rtEvtChanged = false;
+                            this.popRtEvent();
+                            this.pushRtEvent(rtEvt);
+                        }
+                        if (rtEvt.getInternalCode() !== InternalInterface.MG_ACT_TASK_PREFIX && task.isStarted() && task.getExecEndTask()) {
+                            endTaskError = await task.endTask(true, false, false);
+                            if (endTaskError)
+                                break;
+                        }
+                        if (this.GetStopExecutionFlag()) {
+                            if (await this.handleStopExecution(rtEvt))
+                                break;
+                        }
+                    }
+                    finally {
+                        handler.getTask().SetContextTask(handlerContextTask);
+                    }
+                    if (!propagate)
+                        break;
+                    if (rtEvtChanged)
+                        handler = pos.getNext(rtEvt);
+                    else
+                        handler = pos.getNext();
+                    if (handler !== null)
+                        FlowMonitorQueue.Instance.addTaskEvent(rtEvt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_PROPAGATE, task.GetTaskDetails());
+                }
+                if (propagate && !endTaskError)
+                    await this.commonHandler(rtEvt);
+            }
+            if (!endTaskError) {
+                await this.commonHandlerAfter(rtEvt, bRcBefore);
+            }
+            if (forceExitDone && this._isHandlingForceExit) {
+                this._isHandlingForceExit = false;
+                await this.handleForceExitAfter(rtEvt);
+            }
+            this.setForceExit(oldForceExit, oldForceExitTask);
+            if (restoreIsForceExit)
+                this._isHandlingForceExit = oldIsHandlingForceExit;
+        }
+        finally {
+            this._currCtrl = restoreCurrCtrl;
+            this._currField = restoreCurrField;
+            this.popRtEvent();
+        }
+        GUIManager.Instance.execGuiCommandQueue();
+    }
+    async simulateSelection(ctrl, val, line, produceClick) {
+        let mgControl = ctrl;
+        let currTask = mgControl.getForm().getTask();
+        let cancelWasRaised = currTask.cancelWasRaised();
+        if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON) {
+            let aRtEvt = new RunTimeEvent(mgControl);
+            let raiseAt = (await (mgControl.getProp(PropInterface.PROP_TYPE_RAISE_AT)).getValueInt());
+            if (aRtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && (aRtEvt.InternalEvent === InternalInterface.MG_ACT_CANCEL || aRtEvt.InternalEvent === InternalInterface.MG_ACT_RT_QUIT)) {
+                if (raiseAt === RaiseAt.TaskInFocus)
+                    currTask = LastFocusedManager.Instance.getLastFocusedTask();
+                cancelWasRaised = currTask.cancelWasRaised();
+                currTask.setCancelWasRaised(true);
+            }
+            if (raiseAt === RaiseAt.TaskInFocus)
+                mgControl.setRtEvtTask(LastFocusedManager.Instance.getLastFocusedTask());
+        }
+        await this.handleFocus(mgControl, line, produceClick);
+        currTask.setCancelWasRaised(cancelWasRaised);
+        if (this._stopExecution)
+            return;
+        let controlIsParkable = await mgControl.IsParkable();
+        if (mgControl.Type !== MgControlType.CTRL_TYPE_BUTTON || (mgControl.getField() === null || controlIsParkable)) {
+            if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON && !controlIsParkable) {
+                let subformTask = mgControl.getForm().getTask();
+                if (subformTask.IsSubForm) {
+                    currTask = LastFocusedManager.Instance.getLastFocusedTask();
+                    if (subformTask !== currTask && subformTask.pathContains(currTask)) {
+                        if (subformTask.getLevel() === Constants.TASK_LEVEL_TASK) {
+                            await this.handleInternalEventWithTask(subformTask, InternalInterface.MG_ACT_REC_PREFIX);
+                        }
+                        await this.HandleNonParkableControls(subformTask);
+                    }
+                }
+            }
+            let rtEvt = new RunTimeEvent(mgControl);
+            RuntimeContextBase.Instance.CurrentClickedCtrl = mgControl;
+            rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_HIT);
+            await this.handleEvent(rtEvt, false);
+            if (this._stopExecution)
+                return;
+        }
+        if (mgControl.Type !== MgControlType.CTRL_TYPE_BUTTON)
+            await this.handleSelection(mgControl, line, val);
+        if (this._stopExecution)
+            return;
+        await this.handleMouseUp(mgControl, line, produceClick);
+    }
+    async handleInternalEventWithTask(itask, eventCode) {
+        await this.handleInternalEventWithTaskAndSubformRefresh(itask, eventCode, false);
+    }
+    async handleInternalEventWithTaskAndSubformRefresh(itask, eventCode, subformRefresh) {
+        let task = itask;
+        if (eventCode === InternalInterface.MG_ACT_REC_PREFIX && task.IsSubForm && task.SubformExecMode !== Task_SubformExecModeEnum.FIRST_TIME) {
+            task.SubformExecMode = (subformRefresh ? Task_SubformExecModeEnum.REFRESH : Task_SubformExecModeEnum.SET_FOCUS);
+        }
+        if (subformRefresh)
+            await this.handleInternalEventWithTask(itask, InternalInterface.MG_ACT_POST_REFRESH_BY_PARENT);
+        if (task.DataView.isEmptyDataview()) {
+            if (eventCode === InternalInterface.MG_ACT_REC_PREFIX || eventCode === InternalInterface.MG_ACT_REC_SUFFIX) {
+                if (eventCode === InternalInterface.MG_ACT_REC_PREFIX)
+                    await task.emptyDataviewOpen(subformRefresh);
+                else
+                    task.emptyDataviewClose();
+                if (task.getForm() !== null) {
+                    if (eventCode === InternalInterface.MG_ACT_REC_PREFIX)
+                        await task.getForm().RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                    task.getForm().SelectRow();
+                }
+            }
+            else
+                await this.handleInternalEventWithTaskAndEventSubtype(task, eventCode, EventSubType.Normal);
+        }
+        else
+            await this.handleInternalEventWithTaskAndEventSubtype(task, eventCode, EventSubType.Normal);
+    }
+    async handleInternalEventWithMgControlBase(ctrl, eventCode) {
+        await this.handleInternalEventWithMgControl(ctrl, eventCode, EventSubType.Normal);
+    }
+    GetStopExecutionFlag() {
+        return this._stopExecution;
+    }
+    getStopExecutionCtrl() {
+        return this._stopExecutionCtrl;
+    }
+    Init() {
+        if (this._initialized) {
+            this._isHandlingForceExit = false;
+            this._forceExit = ForceExit.None;
+            this._forceExitTask = null;
+            this._currField = null;
+            this.setEndOfWork(true);
+        }
+        this._initialized = true;
+    }
+    addInternalEventWithItaskAndCode(itask, code) {
+        this.addGuiTriggeredEventWithTaskAndCodeAndOnMultiMark(itask, code);
+    }
+    addInternalEventWithCtrlAndCode(ctrl, code) {
+        let rtEvt = new RunTimeEvent(ctrl);
+        rtEvt.setInternal(code);
+        this.addToTail(rtEvt);
+    }
+    addInternalEventWithCtrlAndDisplayLineAndCode(ctrl, DisplayLine, code) {
+        let rtEvt = new RunTimeEvent(ctrl, DisplayLine, false);
+        rtEvt.setInternal(code);
+        this.addToTail(rtEvt);
+    }
+    addInternalEventWithCtrlAndCodeAndPriority(ctrl, code, priority) {
+        let rtEvt = new RunTimeEvent(ctrl);
+        rtEvt.setInternal(code);
+        rtEvt.setPriority(priority);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventWithTaskAndCodeAndOnMultiMark(itask, code) {
+        let task = itask;
+        let rtEvt = new RunTimeEvent(task);
+        rtEvt.setInternal(code);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventWithCtrlAndCodeAndLineAndModifier(ctrl, code, line) {
+        let rtEvt = new RunTimeEvent(ctrl, line, false);
+        rtEvt.setInternal(code);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventWithTaskAndCodeAndLine(task, code, line) {
+        let tsk = null;
+        if (task !== null)
+            tsk = task;
+        let rtEvt = new RunTimeEvent(tsk);
+        rtEvt.setInternal(code);
+        rtEvt.DisplayLine = line;
+        this.addToTail(rtEvt);
+    }
+    AddColumnClickEvent(columnCtrl, direction, columnHeader) {
+        let rtEvt = new RunTimeEvent(columnCtrl, direction, 0);
+        rtEvt.setInternal(InternalInterface.MG_ACT_COL_CLICK);
+        let argsList = new Array();
+        argsList[0] = new ExpVal(StorageAttribute.UNICODE, false, columnHeader);
+        let args = new ArgumentsList(argsList);
+        rtEvt.setArgList(args);
+        this.addToTail(rtEvt);
+    }
+    AddRouteEvent(task, code, routerpath, routerOutletName, routeParams) {
+        let rtEvt = new RunTimeEvent(task, true);
+        rtEvt.setInternal(code);
+        let argsList = new Array(2);
+        argsList[0] = new ExpVal(StorageAttribute.ALPHA, false, routerpath);
+        if (routerOutletName === null)
+            routerOutletName = '';
+        argsList[1] = new ExpVal(StorageAttribute.ALPHA, false, routerOutletName);
+        let args = new ArgumentsList(argsList);
+        rtEvt.setArgList(args);
+        rtEvt.setRouteParamList(routeParams);
+        this.addToTail(rtEvt);
+    }
+    AddRouterClosedEvent(task) {
+        let subFormControl = task.getForm().getSubFormCtrl();
+        let rtEvt = new RunTimeEvent(subFormControl.getForm().getTask(), true);
+        rtEvt.setInternal(InternalInterface.MG_ACT_SUBFORM_CLOSE);
+        let argsList = new Array(1);
+        argsList[0] = new ExpVal(StorageAttribute.ALPHA, false, subFormControl.getName());
+        let args = new ArgumentsList(argsList);
+        rtEvt.setArgList(args);
+        EventsManager.Instance.addToTail(rtEvt);
+    }
+    AddLastSavedRouteEvent(srcTask, args) {
+        let rtEvt = new RunTimeEvent(LastFocusedManager.Instance.getLastFocusedTask(), true);
+        rtEvt.setInternal(InternalInterface.MG_ACT_WEBCLIENT_ROUTE);
+        if (srcTask != null) {
+            rtEvt.setTask(srcTask);
+            if (args != null) {
+                rtEvt.setArgList(args);
+            }
+            this.setLastSavedRouteEvent(rtEvt);
+        }
+    }
+    AddExternalValueEvent(ctrl, value, refreshDisplay) {
+        let rtEvt = new RunTimeEvent(ctrl, 0, true);
+        rtEvt.setInternal(InternalInterface.MG_ACT_SET_EXTERNAL_VALUE);
+        rtEvt.setValue(value);
+        let argsList = new Array(1);
+        argsList[0] = new ExpVal(StorageAttribute.BOOLEAN, false, refreshDisplay ? '1' : '0');
+        let args = new ArgumentsList(argsList);
+        rtEvt.setArgList(args);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventWithCtrlAndCodeAndLine(ctrl, code, line) {
+        let rtEvt = new RunTimeEvent(ctrl, line, true);
+        rtEvt.setInternal(code);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventWithCtrlAndLineAndCodeAndIsProductClick(ctrl, code, line, isProduceClick) {
+        let rtEvt = new RunTimeEvent(ctrl, line, true);
+        rtEvt.setInternal(code);
+        rtEvt.setProduceClick(isProduceClick);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventWithCtrlAndCodeAndList(ctrl, code, list) {
+        let rtEvt = new RunTimeEvent(ctrl, list, true);
+        rtEvt.setInternal(code);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventWithTaskAndCode(task, code) {
+        let rtEvt = new RunTimeEvent(task, true);
+        rtEvt.setInternal(code);
+        this.addToTail(rtEvt);
+    }
+    addGuiTriggeredEventTaskAndCodeAndRaisedBy(task, code) {
+        this.addGuiTriggeredEventWithTaskAndCode(task, code);
+    }
+    getEvent() {
+        return this._eventsQueue.poll();
+    }
+    getForceExit() {
+        return this._forceExit;
+    }
+    setForceExit(forceExit, task) {
+        this._forceExit = forceExit;
+        this.setForceExitTask(task);
+    }
+    getForceExitTask() {
+        return this._forceExitTask;
+    }
+    setForceExitTask(task) {
+        this._forceExitTask = task;
+    }
+    isForceExitPreRecordUpdate(task) {
+        return this._isHandlingForceExit && this.getForceExit() === ForceExit.PreRecordUpdate && task === this.getForceExitTask();
+    }
+    async ExecuteClientContextInactivityTimer() {
+        let startTime = Misc.getSystemMilliseconds();
+        let clientCtxInactivityTimeout = Environment.Instance.getClientContextInactivityTimeout() * 100;
+        EventsManager.clientInactivityTimerON = true;
+        while (EventsManager.clientInactivityTimerON) {
+            await Thread.Sleep(1000);
+            var timeLapsed = Misc.getSystemMilliseconds() - startTime;
+            if (EventsManager.clientContextInactivityTimerAborted || timeLapsed >= clientCtxInactivityTimeout) {
+                EventsManager.clientInactivityTimerON = false;
+            }
+        }
+    }
+    async CheckAndShowSpinner(show) {
+        let sendCommand = false;
+        if (this.getLastRtEvent() !== null && this.getLastRtEvent().getPriority() === Priority.LOWEST)
+            show = false;
+        if (show != this.isSpinnerShown) {
+            if (show) {
+                if (Misc.getSystemMilliseconds() - this.GetEventTime() > 1000) {
+                    sendCommand = true;
+                    EventsManager.clientBusyTimeStart = Misc.getSystemMilliseconds();
+                }
+            }
+            else
+                sendCommand = true;
+            if (sendCommand) {
+                Commands.addShowSpinner(show);
+                Commands.beginInvoke();
+                await Thread.Sleep(50);
+                this.isSpinnerShown = show;
+                if (!this.isSpinnerShown) {
+                    let totalClientBusyTime = Misc.getSystemMilliseconds() - EventsManager.clientBusyTimeStart;
+                    this.SpinnerStopped.next(totalClientBusyTime);
+                    EventsManager.clientBusyTimeStart = 0;
+                }
+            }
+        }
+    }
+    async EventsLoop(mgData) {
+        let savedAllowEvents = this.getAllowEvents();
+        this.setAllowEvents(EventsAllowedType.ALL);
+        this.pushNewExecStacks();
+        while (!mgData.IsAborting) {
+            await this.CheckAndShowSpinner(false);
+            await this._eventsQueue.waitForElement();
+            await this.handleEvents(mgData, 0);
+            if (!mgData.IsAborting)
+                await this.checkParkability();
+        }
+        this.popNewExecStacks();
+        this.setAllowEvents(savedAllowEvents);
+    }
+    async NonInteractiveEventsLoop(mgData, taskBase) {
+        let task = taskBase;
+        let savedAllowEvents = this.getAllowEvents();
+        this.setNonInteractiveAllowEvents(await task.isAllowEvents());
+        this.pushNewExecStacks();
+        while (!mgData.IsAborting) {
+            if (task.getMode() === Constants.TASK_MODE_DELETE)
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_CYCLE_NEXT_DELETE_REC);
+            else
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_CYCLE_NEXT_REC);
+            await Thread.Sleep(10);
+            if (!mgData.IsAborting && await task.isAllowEvents())
+                await this.handleEvents(mgData, 1);
+        }
+        this.popNewExecStacks();
+        this.setAllowEvents(savedAllowEvents);
+    }
+    async handleEvents(baseMgDataOrHandlersTab, eventsToHandleCntOrRtEvt) {
+        if ((baseMgDataOrHandlersTab === null || baseMgDataOrHandlersTab instanceof MGData) && (eventsToHandleCntOrRtEvt === null || eventsToHandleCntOrRtEvt.constructor === Number)) {
+            await this.handleEvents_0(baseMgDataOrHandlersTab, eventsToHandleCntOrRtEvt);
+            return;
+        }
+        await this.handleEvents_1(baseMgDataOrHandlersTab, eventsToHandleCntOrRtEvt);
+    }
+    async handleEvents_0(baseMgData, eventsToHandleCnt) {
+        let task = null;
+        let delta = 0;
+        let eventsPolledCnt = 0;
+        this.setStopExecution(false);
+        while (!this._eventsQueue.isEmpty() && !this._stopExecution && (eventsToHandleCnt === 0 || eventsPolledCnt < eventsToHandleCnt)) {
+            let rtEvt = this.getEvent();
+            if (rtEvt !== null && rtEvt.isGuiTriggeredEvent()) {
+                delta = Misc.getSystemMilliseconds();
+                this._currKbdItem = null;
+                let blockedByModalWindow = rtEvt.isBlockedByModalWindow(baseMgData);
+                if (blockedByModalWindow && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_TIMER) {
+                    continue;
+                }
+                if (!rtEvt.isIdleTimer() && !blockedByModalWindow && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_ENABLE_EVENTS && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_DISABLE_EVENTS && rtEvt.getTask() !== null && !rtEvt.getTask().getMGData().IsAborting) {
+                    MGDataCollection.Instance.currMgdID = rtEvt.getTask().getMGData().GetId();
+                }
+            }
+            let currMgd = MGDataCollection.Instance.getCurrMGData();
+            if (currMgd !== null) {
+                while (currMgd !== null && currMgd.IsAborting) {
+                    currMgd = currMgd.getParentMGdata();
+                    if (currMgd !== null)
+                        MGDataCollection.Instance.currMgdID = MGDataCollection.Instance.getMgDataIdx(currMgd);
+                }
+            }
+            else {
+                task = rtEvt.getTask();
+                while (currMgd === null && task !== null && task.getParent() !== null) {
+                    task = task.getParent();
+                    currMgd = task.getMGData();
+                    if (currMgd.IsAborting)
+                        currMgd = null;
+                    if (currMgd !== null)
+                        MGDataCollection.Instance.currMgdID = MGDataCollection.Instance.getMgDataIdx(currMgd);
+                }
+            }
+            if (currMgd === null)
+                break;
+            if (rtEvt.getTask() === null) {
+                task = LastFocusedManager.Instance.getLastFocusedTask();
+                while (task !== null && (task.isAborting() || task.InEndTask))
+                    task = task.getParent();
+                if (task !== null) {
+                    rtEvt.setCtrl(task.getLastParkedCtrl());
+                    rtEvt.setTask(task);
+                }
+            }
+            else
+                task = rtEvt.getTask();
+            if (task !== null) {
+                await this.handleEvent(rtEvt, false);
+            }
+            GUIManager.Instance.execGuiCommandQueue();
+            this._currCtrl = null;
+            if (task !== null)
+                await Task.CommandsProcessor.SendMonitorOnly();
+            else {
+                await Task.CommandsProcessor.SendMonitorOnly();
+            }
+            if (rtEvt !== null && rtEvt.isGuiTriggeredEvent()) {
+                if (delta > 0) {
+                    delta = Misc.getSystemMilliseconds() - delta;
+                }
+            }
+            if (eventsToHandleCnt > 0 && rtEvt !== null && rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.InternalEvent < InternalInterface.MG_ACT_TOT_CNT)
+                eventsPolledCnt++;
+        }
+    }
+    async handleStopExecution(rtEvt) {
+        let stop = false;
+        if (!this.GetStopExecutionFlag())
+            return stop;
+        let task = rtEvt.getTask();
+        let currCtrl = rtEvt.Control;
+        let lastParkedCtrl = LastFocusedManager.getLastFocusedControl();
+        let endTaskDueToVerifyError = false;
+        if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {
+            switch (rtEvt.getInternalCode()) {
+                case InternalInterface.MG_ACT_TASK_PREFIX:
+                    endTaskDueToVerifyError = true;
+                    break;
+                case InternalInterface.MG_ACT_REC_PREFIX:
+                    endTaskDueToVerifyError = true;
+                    break;
+                case InternalInterface.MG_ACT_REC_SUFFIX:
+                    this.setStopExecutionCtrl(null);
+                    this.setStopExecutionCtrl(task.getLastParkedCtrl());
+                    break;
+                case InternalInterface.MG_ACT_CTRL_PREFIX:
+                    this.setStopExecution(false);
+                    task.InCtrlPrefix = false;
+                    if (lastParkedCtrl === null) {
+                        task.setCurrField(null);
+                        this.setStopExecutionCtrl(null);
+                        this.setStopExecutionCtrl(currCtrl);
+                        await this.HandleNonParkableControls(task);
+                    }
+                    else {
+                        task.setCurrField(lastParkedCtrl.getField());
+                        await FocusManager.SetFocus(lastParkedCtrl, -1);
+                    }
+                    this.setStopExecution(true);
+                    break;
+                case InternalInterface.MG_ACT_CTRL_SUFFIX:
+                    currCtrl.setInControlSuffix(false);
+                    break;
+            }
+            if (endTaskDueToVerifyError) {
+                await task.endTask(true, false, true);
+                stop = true;
+            }
+        }
+        return stop;
+    }
+    async handleForceExitBefore(evt, rtEvt) {
+        let forceExit = evt.UserEvt.ForceExit;
+        let isNewRec = false;
+        let oldIdx = 0;
+        if (forceExit === ForceExit.None || rtEvt.isImmediate())
+            return false;
+        this._isHandlingForceExit = true;
+        let task = rtEvt.getTask();
+        let oldRec = task.DataView.getCurrRec();
+        if (oldRec !== null && oldRec.getMode() === DataModificationTypes.Insert && oldRec.isNewRec()) {
+            isNewRec = true;
+            oldIdx = oldRec.getId();
+        }
+        if (forceExit !== ForceExit.Editing && task.getLevel() === Constants.TASK_LEVEL_CONTROL) {
+            let ctrl = task.getLastParkedCtrl();
+            if (ctrl !== null)
+                await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_SUFFIX);
+        }
+        if ((forceExit === ForceExit.PreRecordUpdate || forceExit === ForceExit.PostRecordUpdate) && task.getLevel() === Constants.TASK_LEVEL_RECORD) {
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+            if (task.getMode() === Constants.TASK_MODE_CREATE && !this._stopExecution)
+                task.setMode(Constants.TASK_MODE_MODIFY);
+            let currRec = task.DataView.getCurrRec();
+            if (currRec !== null && this._stopExecution && isNewRec && oldIdx === currRec.getId() && task.getMode() === Constants.TASK_MODE_CREATE) {
+                currRec.clearMode();
+                currRec.restart(DataModificationTypes.Insert);
+            }
+        }
+        if (forceExit === ForceExit.PostRecordUpdate && !this._stopExecution) {
+            if (task.getLevel() === Constants.TASK_LEVEL_TASK)
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+        }
+        if (forceExit === ForceExit.Editing) {
+            let evtCtrl = rtEvt.Control;
+            if (evtCtrl !== null && evtCtrl.getField() !== null) {
+                let ctrlVal = Manager.GetCtrlVal(evtCtrl);
+                await evtCtrl.validateAndSetValue(ctrlVal, true);
+            }
+        }
+        return true;
+    }
+    async handleForceExitAfter(rtEvt) {
+        let forceExit = rtEvt.UserEvt.ForceExit;
+        let task = rtEvt.getTask();
+        if (forceExit === ForceExit.PreRecordUpdate) {
+            await this.commitRecord(task, true);
+            if (!task.transactionFailed(ConstInterface.TRANS_RECORD_PREFIX) && !task.isAborting()) {
+                if (await task.evalEndCond(ConstInterface.END_COND_EVAL_AFTER))
+                    await task.endTask(true, false, false);
+            }
+        }
+        if (forceExit !== ForceExit.PostRecordUpdate) {
+            task = rtEvt.getTask();
+            if (task.getLevel() === Constants.TASK_LEVEL_TASK)
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+        }
+        let ctrl = LastFocusedManager.getLastFocusedControl();
+        if (ctrl !== null && forceExit !== ForceExit.Editing) {
+            await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_PREFIX);
+        }
+        if (forceExit === ForceExit.Editing) {
+            let evtCtrl = rtEvt.Control;
+            if (evtCtrl !== null && evtCtrl.getField() !== null)
+                await evtCtrl.getField().updateDisplay();
+        }
+    }
+    async handleEvents_1(handlersTab, rtEvt) {
+        try {
+            this.pushRtEvent(rtEvt);
+            for (let i = 0; i < handlersTab.getSize(); i++) {
+                let handler = handlersTab.getHandler(i);
+                if (rtEvt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION || handler.isSpecificHandlerOf(rtEvt) || handler.isNonSpecificHandlerOf(rtEvt) || handler.isGlobalHandlerOf(rtEvt)) {
+                    await handler.execute(rtEvt, false, false);
+                }
+            }
+        }
+        finally {
+            this.popRtEvent();
+        }
+    }
+    async handleKeyDown(task, ctrl, evt) {
+        let kbdItem = evt.getKbdItmAlways();
+        let keyCode = kbdItem.getKeyCode();
+        this._currKbdItem = kbdItem;
+        if (evt.IgnoreSpecifiedControl) {
+            ctrl = this.getCurrCtrl();
+            task = (((ctrl.getForm().getTask() instanceof Task) ? ctrl.getForm().getTask() : null));
+            if (ctrl.Type !== MgControlType.CTRL_TYPE_TEXT)
+                return;
+        }
+        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))
+                    return;
+            }
+            let rtEvt = new RunTimeEvent(task, ctrl);
+            rtEvt.setSystem(this._currKbdItem);
+            rtEvt.setEditParms(evt.getStartSelection(), evt.getEndSelection(), evt.getValue());
+            try {
+                await this.handleEvent(rtEvt, false);
+            }
+            finally {
+                if (this._stopExecution) {
+                    let returnToCtrl = MgControl.ReturnToCtrl;
+                    if (returnToCtrl !== null && MgControl.validReturnToCtrl())
+                        returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);
+                }
+            }
+            let mgd = MGDataCollection.Instance.getCurrMGData();
+            if (mgd !== null && !mgd.IsAborting)
+                await this.handleExpressionHandlers();
+            Logger.Instance.WriteDevToLog('End handling KEYDOWN event. Key code: ' + keyCode);
+            if (ctrl !== null && ctrl.IsRepeatable && ctrl === MgControl.ReturnToCtrl) {
+                await ctrl.getForm().bringRecordToPage();
+            }
+        }
+        finally {
+        }
+    }
+    async handleSelection(ctrl, line, val) {
+        if (ctrl.Type === MgControlType.CTRL_TYPE_TAB || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_COMBO || ctrl.Type === MgControlType.CTRL_TYPE_LIST) {
+            let checkFocus = (ctrl.Type !== MgControlType.CTRL_TYPE_TAB && ctrl.Type !== MgControlType.CTRL_TYPE_CHECKBOX);
+            let allowSelection = (checkFocus ? (ctrl.getForm().getTask().getLastParkedCtrl() === ctrl) : true);
+            if (!allowSelection || !ctrl.isModifiable() || !await ctrl.IsParkable())
+                await ctrl.restoreOldValue();
+            else {
+                if (ctrl.isChoiceControl())
+                    Commands.setGetSuggestedValueOfChoiceControlOnTagData(ctrl, ctrl.IsRepeatable ? line : 0, true);
+                if (ctrl.isDifferentValue(val, ctrl.IsNull, true)) {
+                    ctrl.ModifiedByUser = true;
+                    await this.handleCtrlModify(ctrl, InternalInterface.MG_ACT_SELECTION);
+                }
+                if (ctrl.isChoiceControl())
+                    Commands.setGetSuggestedValueOfChoiceControlOnTagData(ctrl, ctrl.IsRepeatable ? line : 0, false);
+                if (!ctrl.IsMultipleSelectionListBox())
+                    await ctrl.validateAndSetValue(val, true);
+            }
+        }
+    }
+    async handleMouseUp(ctrl, line, produceClick) {
+        if (ctrl === null)
+            return;
+        if (ctrl.Type === MgControlType.CTRL_TYPE_RADIO)
+            RuntimeContextBase.Instance.CurrentClickedRadio = ctrl;
+        try {
+            if (ctrl.Type !== MgControlType.CTRL_TYPE_TABLE) {
+                if (!await ctrl.checkPropWithLine(PropInterface.PROP_TYPE_ENABLED, true, line)) {
+                    return;
+                }
+                let canGotoCtrl = this.canGoToControl(ctrl, true);
+                let StopFocus = ctrl.isFocusedStopExecution();
+                let returnToCtrl = MgControl.ReturnToCtrl;
+                if ((!canGotoCtrl || ((this._stopExecution || StopFocus) && returnToCtrl !== ctrl)) && returnToCtrl !== null) {
+                    MGDataCollection.Instance.currMgdID = returnToCtrl.getForm().getTask().getMgdID();
+                    if (returnToCtrl.IsRepeatable)
+                        await returnToCtrl.getForm().bringRecordToPage();
+                    await FocusManager.SetFocus(returnToCtrl, -1);
+                    returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);
+                }
+                if (this._stopExecution || StopFocus)
+                    return;
+            }
+            if (produceClick && (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_LIST)) {
+                let rtEvt = new RunTimeEvent(ctrl);
+                rtEvt.setInternal(InternalInterface.MG_ACT_WEB_CLICK);
+                this.addToTail(rtEvt);
+            }
+        }
+        finally {
+            RuntimeContextBase.Instance.CurrentClickedRadio = null;
+        }
+    }
+    checkAndSaveRouteEventIfCtxRemovedFromSrvr(aRtEvt) {
+        if (aRtEvt.getType() == ConstInterface.EVENT_TYPE_INTERNAL && aRtEvt.getInternalCode() ==
+            InternalInterface.MG_ACT_WEBCLIENT_ROUTE && RuntimeContextBase.Instance.RemovedContextFromServer) {
+            this.setLastSavedRouteEvent(aRtEvt);
+        }
+    }
+    async handleFocus(ctrl, line, onClick) {
+        try {
+            if (ctrl.isStatic())
+                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));
+                    FocusManager.SetFocus(LastFocusedManager.Instance.getLastFocusedTask(), LastFocusedManager.getLastFocusedControl(), 0, LastFocusedManager.getLastFocusedControl() === null ? true : false);
+                    this._lastFailedFocusedControl = ctrl;
+                    return;
+                }
+            }
+            this._lastFailedFocusedControl = null;
+            if (onClick)
+                RuntimeContextBase.Instance.CurrentClickedCtrl = ctrl;
+            let prevCtrl = LastFocusedManager.getLastFocusedControl();
+            if (ctrl === prevCtrl && !ctrl.isRepeatable()) {
+                await ctrl.getForm().bringRecordToPage();
+                return;
+            }
+            let prevTask = LastFocusedManager.Instance.getLastFocusedTask();
+            if (ctrl === null || ctrl.Type === MgControlType.CTRL_TYPE_TABLE) {
+                if (prevCtrl === null)
+                    await this.HandleNonParkableControls(ctrl.getForm().getTask());
+                return;
+            }
+            let currTask;
+            if ((ctrl.Type === MgControlType.CTRL_TYPE_BUTTON) && ((await (ctrl.getProp(PropInterface.PROP_TYPE_RAISE_AT)).getValueInt()) === RaiseAt.TaskInFocus))
+                currTask = prevTask;
+            else
+                currTask = ctrl.getForm().getTask();
+            let canGotoCtrl = this.canGoToControl(ctrl, onClick);
+            if (canGotoCtrl) {
+                if (this.guiPendingEvent != null)
+                    return;
+                let handled = await this.HandleSubformModality(ctrl, prevTask, currTask);
+                if (handled)
+                    return;
+                let eventLine = (ctrl.isRepeatable() || ctrl.isRadio()) ? line : Int32.MinValue;
+                let rtEvt = new RunTimeEvent(ctrl, eventLine);
+                rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_PREFIX);
+                await this.handleEvent(rtEvt, false);
+            }
+            else if (prevCtrl !== null) {
+                if (!prevCtrl.isModifiable()) {
+                    if (prevCtrl.isChoiceControl())
+                        await prevCtrl.restoreOldValue();
+                }
+                else if (!currTask.cancelWasRaised()) {
+                    let newVal = Manager.GetCtrlVal(prevCtrl);
+                    if (!await prevCtrl.validateAndSetValue(newVal, true))
+                        this.setStopExecution(true);
+                }
+                MgControl.ReturnToCtrl = prevCtrl;
+            }
+            else
+                await this.HandleNonParkableControls(ctrl.getForm().getTask());
+            if (!this._stopExecution && MgControl.ReturnToCtrl === ctrl)
+                LastFocusedManager.setLastFocusedControl(ctrl.getForm().getTask(), ctrl);
+            return;
+        }
+        finally {
+            ctrl.setFocusedStopExecution(this._stopExecution);
+            if (this._stopExecution) {
+                {
+                    let returnToCtrl = MgControl.ReturnToCtrl;
+                    if (returnToCtrl !== null) {
+                        MGDataCollection.Instance.currMgdID = returnToCtrl.getForm().getTask().getMgdID();
+                        await FocusManager.SetFocus(returnToCtrl, -1);
+                        returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);
+                    }
+                }
+            }
+        }
+    }
+    async HandleSubformModality(ctrl, prevTask, currTask) {
+        let handledSubformModality = false;
+        let length = prevTask.getMGData().getTasksCount();
+        let topTask = prevTask.getMGData().getTask(length - 1);
+        if (currTask == prevTask || prevTask != topTask) {
+            if (topTask != null && prevTask != topTask && topTask.IsSubForm) {
+                let subformCtrl = topTask.getForm().getSubFormCtrl();
+                if (subformCtrl.IsModal())
+                    prevTask = topTask;
+            }
+        }
+        if (prevTask != ctrl.getForm().getTask() && prevTask.getIsDestinationCall()) {
+            if (!currTask.isDescendentOf(prevTask)) {
+                let subformCtrl = prevTask.getForm().getSubFormCtrl();
+                if (!subformCtrl.IsModal() && !currTask.getIsDestinationCall())
+                    subformCtrl = prevTask.GetSubformModalParentTask();
+                if (subformCtrl != null && (ctrl != subformCtrl) && subformCtrl.IsModal()) {
+                    await this.performSubformClose(subformCtrl);
+                    if (!this._stopExecution)
+                        this.guiPendingEvent = this.getLastRtEvent();
+                    handledSubformModality = true;
+                }
+            }
+        }
+        return handledSubformModality;
+    }
+    async handleFocusOnNonMagicControl(ctrl) {
+        try {
+            await EventsManager.Instance.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_SUFFIX);
+        }
+        finally {
+            ctrl.setFocusedStopExecution(this._stopExecution);
+            if (this._stopExecution) {
+                {
+                    let returnToCtrl = MgControl.ReturnToCtrl;
+                    if (returnToCtrl !== null) {
+                        MGDataCollection.Instance.currMgdID = returnToCtrl.getForm().getTask().getMgdID();
+                        await FocusManager.SetFocus(returnToCtrl, -1);
+                        returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);
+                    }
+                }
+            }
+        }
+    }
+    canGoToControl(ctrl, onClick) {
+        if (onClick && (ctrl.Type === MgControlType.CTRL_TYPE_SUBFORM || ctrl.Type === MgControlType.CTRL_TYPE_BROWSER))
+            return false;
+        let canGotoCtrl = true;
+        let currTask = ctrl.getForm().getTask();
+        let lastTask = LastFocusedManager.Instance.getLastFocusedTask();
+        if (!currTask.IsInteractive || (lastTask != null && lastTask.getLastParkedCtrl() != null &&
+            lastTask.cancelWasRaised()))
+            return false;
+        if (ctrl.Type === MgControlType.CTRL_TYPE_IMAGE && !ctrl.IsRepeatable)
+            canGotoCtrl = false;
+        return canGotoCtrl;
+    }
+    async handleTimer(evt) {
+        evt.setType(ConstInterface.EVENT_TYPE_TIMER);
+        if (evt.isIdleTimer()) {
+            await this.handleExpressionHandlers();
+            await this.handleContextInactivityAlert(evt);
+        }
+        else {
+            let mgd = MGDataCollection.Instance.getMGData(evt.getMgdID());
+            await this.handleEvents(mgd.getTimerHandlers(), evt);
+        }
+    }
+    async handleContextInactivityAlert(evt) {
+        let timeNow = Misc.getSystemMilliseconds();
+        let mgd = evt.getTask().getMGData();
+        let lastRequestTime = RemoteCommandsProcessor.GetInstance().GetLastRequestTime;
+        let contextInactivityTimeout = Environment.Instance.getContextInactivityTimeout() / 10;
+        let contextInactivityWarningTime = Environment.Instance.getContextInactivityWarningTime() / 10;
+        let idleTime = (timeNow - lastRequestTime) / 1000;
+        if (contextInactivityTimeout == 0 || contextInactivityWarningTime == 0)
+            return;
+        if (EventsManager.userGrantedForContextActivity && idleTime >= (contextInactivityTimeout - contextInactivityWarningTime)) {
+            let userConfirmation = await GUIManager.Instance.MessageBox(this.confirmationDialogTitle, this.confirmationDialogMsg, Styles.MSGBOX_BUTTON_YES_NO);
+            if (userConfirmation == Styles.MSGBOX_RESULT_YES) {
+                let cmd = CommandFactory.CreateContextTimeoutResetEventCommand();
+                mgd.CmdsToServer.Add(cmd);
+                await RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);
+            }
+            else {
+                EventsManager.userGrantedForContextActivity = false;
+            }
+        }
+    }
+    async handleExpressionHandlers() {
+        let rtEvt = new RunTimeEvent(LastFocusedManager.Instance.getLastFocusedTask(), LastFocusedManager.getLastFocusedControl());
+        rtEvt.setExpression(null);
+        rtEvt.setMainPrgCreator(rtEvt.getTask());
+        for (let i = 0; i < MGDataCollection.Instance.getSize(); i++) {
+            let mgd = MGDataCollection.Instance.getMGData(i);
+            if (mgd !== null && !mgd.IsAborting)
+                await this.handleEvents(mgd.getExpHandlers(), rtEvt);
+        }
+    }
+    handleResize(ctrl, rowsInPage) {
+        ctrl.getForm().setRowsInPage(rowsInPage);
+    }
+    async handleRowDataCurPage(table, desiredTopIndex, sendAll, lastFocusedVal) {
+        let form = table.getForm();
+        await form.setRowData(desiredTopIndex, sendAll);
+    }
+    async handleTransferDataToGui(ctrl) {
+        let form = ctrl.getForm();
+        await form.transferDataToGui();
+    }
+    async fetchRecordsAheadFromServer(ctrl) {
+        let form = ctrl.getForm();
+        await form.FetchRecordsAheadFromServer();
+    }
+    handleEnableEvents(evt, enable) {
+        evt.getTask().ActionManager.enableList(evt.getActEnableList(), enable, true);
+    }
+    async handleCtrlPrefix(evt) {
+        let task = evt.getTask();
+        let currClickedCtrl = RuntimeContextBase.Instance.CurrentClickedCtrl;
+        let form = task.getForm();
+        let displayLine = evt.getDisplayLine();
+        let ctrl = evt.Control;
+        if (form.isLineMode()) {
+            if (displayLine === Int32.MinValue || ctrl.isRadio())
+                displayLine = form.DisplayLine;
+        }
+        else
+            displayLine = Int32.MinValue;
+        let lastParkedCtrl = LastFocusedManager.getLastFocusedControl();
+        if (lastParkedCtrl !== null && lastParkedCtrl.getForm().getTask().getMGData().GetId() === ctrl.getForm().getTask().getMGData().GetId() && lastParkedCtrl.getForm().getTask().getLevel() === Constants.TASK_LEVEL_CONTROL) {
+            if ((ctrl !== lastParkedCtrl || (ctrl.isRepeatable() && displayLine !== ctrl.getDisplayLine(true))) && !lastParkedCtrl.isInControlSuffix()) {
+                await this.handleInternalEventWithMgControlBase(lastParkedCtrl, InternalInterface.MG_ACT_CTRL_SUFFIX);
+                if (this._stopExecution) {
+                    if (ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.isTabControl()) {
+                        ctrl.resetPrevVal();
+                        await ctrl.RefreshDisplay();
+                    }
+                    return false;
+                }
+            }
+            else
+                return false;
+        }
+        if (task.InCtrlPrefix)
+            return false;
+        task.InCtrlPrefix = true;
+        let prevCtrl = lastParkedCtrl;
+        if (currClickedCtrl !== null && currClickedCtrl.getForm().getTask().getMgdID() === ctrl.getForm().getTask().getMgdID() && ctrl.onDiffForm(currClickedCtrl))
+            prevCtrl = currClickedCtrl;
+        if (prevCtrl !== null && ctrl.onDiffForm(prevCtrl)) {
+            let prevTask = prevCtrl.getForm().getTask();
+            await prevTask.execSubformRecSuffix(ctrl.getForm().getTask());
+            if (this._stopExecution) {
+                if (ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.isTabControl()) {
+                    ctrl.resetPrevVal();
+                    await ctrl.RefreshDisplay();
+                }
+                task.InCtrlPrefix = false;
+                return false;
+            }
+            if (ctrl.getForm().getTask().isAborting()) {
+                task.InCtrlPrefix = false;
+                return false;
+            }
+            await EventsManager.doSyncForSubformParent(task);
+        }
+        if (task.DataView.isEmptyDataview())
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+        else {
+            task.SubformExecMode = Task_SubformExecModeEnum.SET_FOCUS;
+            let rtEvt = new RunTimeEvent(ctrl, displayLine);
+            rtEvt.setInternal(InternalInterface.MG_ACT_REC_PREFIX);
+            await this.handleEvent(rtEvt, false);
+        }
+        if (this.GetStopExecutionFlag()) {
+            task.InCtrlPrefix = false;
+            return false;
+        }
+        if (!await ctrl.IsParkable() && ctrl !== lastParkedCtrl) {
+            task.InCtrlPrefix = false;
+            if (lastParkedCtrl === null || !await lastParkedCtrl.invoke())
+                await 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);
+        task.setLevel(Constants.TASK_LEVEL_CONTROL);
+        ctrl.KeyStrokeOn = false;
+        ctrl.ModifiedByUser = false;
+        task.setCurrField(ctrl.getField());
+        if (ctrl.IsRepeatable)
+            await form.bringRecordToPage();
+        if (lastParkedCtrl !== ctrl) {
+            if ((lastParkedCtrl === null && ctrl.getForm().isSubForm()) || (lastParkedCtrl !== null && (ctrl.getForm().isSubForm() || lastParkedCtrl.getForm().isSubForm()))) {
+                let lastParkedTask = null;
+                if (lastParkedCtrl !== null)
+                    lastParkedTask = lastParkedCtrl.getForm().getTask();
+                if (lastParkedTask !== task) {
+                    let firstTime = true;
+                    let isSonSubform;
+                    let parentTask;
+                    if (lastParkedTask !== null) {
+                        isSonSubform = lastParkedTask.IsSubForm;
+                        for (parentTask = lastParkedTask; parentTask !== null && isSonSubform; parentTask = parentTask.getParent()) {
+                            if (!firstTime) {
+                                isSonSubform = parentTask.IsSubForm;
+                                parentTask.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, false);
+                                parentTask.ActionManager.enable(InternalInterface.MG_ACT_DELLINE, false);
+                                parentTask.enableCreateActs(false);
+                            }
+                            else
+                                firstTime = false;
+                        }
+                    }
+                    isSonSubform = task.IsSubForm;
+                    for (parentTask = task.getParent(); (parentTask !== null) && isSonSubform; parentTask = parentTask.getParent()) {
+                        isSonSubform = parentTask.IsSubForm;
+                        if (parentTask.getEnableZoomHandler())
+                            parentTask.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);
+                        await parentTask.setCreateDeleteActsEnableState();
+                    }
+                    await task.enableModes();
+                }
+            }
+        }
+        if (task.getEnableZoomHandler() || ctrl.useZoomHandler())
+            task.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);
+        if (ctrl.isTextControl() || ctrl.isChoiceControl())
+            ctrl.SetKeyboardLanguage();
+        if (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON)
+            task.ActionManager.enable(InternalInterface.MG_ACT_BUTTON, true);
+        await task.setCreateDeleteActsEnableState();
+        let field = ctrl.getField();
+        if (field !== null && field.NullAllowed && ctrl.isModifiable() && ctrl.Type !== MgControlType.CTRL_TYPE_BUTTON)
+            task.ActionManager.enable(InternalInterface.MG_ACT_RT_EDT_NULL, true);
+        return true;
+    }
+    async commonHandlerBefore(evt) {
+        let evtSave = evt;
+        let task = evt.getTask();
+        let rec = null;
+        let prevRec = null;
+        let val;
+        let oldDisplayLine = Int32.MinValue;
+        if (this._stopExecution)
+            return false;
+        if (task.isAborting())
+            return false;
+        if (evt.getType() === ConstInterface.EVENT_TYPE_SYSTEM) {
+            let actId = this.getMatchingAction(evt.getKbdItm());
+            if (actId !== 0 && evt.Control !== null) {
+                evt = new RunTimeEvent(evt, evt);
+                evt.setInternal(actId);
+                evt.setArgList(null);
+                let mgControl = evt.Control;
+                evtSave.setCtrl(mgControl);
+                if (mgControl === null)
+                    return false;
+            }
+        }
+        if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {
+            let form = task.getForm();
+            let displayLine = evt.getDisplayLine();
+            let dv = task.DataView;
+            rec = dv.getCurrRec();
+            let ctrl = evt.Control;
+            let intEvtCode = evt.getInternalCode();
+            let lastFocusedCtrl = LastFocusedManager.getLastFocusedControl();
+            switch (intEvtCode) {
+                case InternalInterface.MG_ACT_ZOOM:
+                    let boolval = await this.selectProg(ctrl);
+                    if (boolval)
+                        return false;
+                case InternalInterface.MG_ACT_WEB_ON_DBLICK:
+                    break;
+                case InternalInterface.MG_ACT_CTRL_FOCUS:
+                    await this.handleFocus(ctrl, displayLine, evt.isProduceClick());
+                    return false;
+                case InternalInterface.MG_ACT_CTRL_FOCUS_ON_NON_MAGIC_CONTROL:
+                    await this.handleFocusOnNonMagicControl(ctrl);
+                    return false;
+                case InternalInterface.MG_ACT_CTRL_KEYDOWN:
+                    await this.handleKeyDown(task, ctrl, evt);
+                    return false;
+                case InternalInterface.MG_ACT_CTRL_MOUSEUP:
+                    await this.handleMouseUp(ctrl, displayLine, evt.isProduceClick());
+                    return false;
+                case InternalInterface.MG_ACT_SELECTION:
+                    await this.onActSelection(ctrl, form, evt);
+                    return false;
+                case InternalInterface.MG_ACT_TIMER:
+                    await this.handleTimer(evt);
+                    return false;
+                case InternalInterface.MG_ACT_RESIZE:
+                    this.handleResize(ctrl, displayLine);
+                    return false;
+                case InternalInterface.MG_ACT_ROW_DATA_CURR_PAGE:
+                    await this.handleRowDataCurPage(ctrl, displayLine, evt.isSendAll(), evt.LastFocusedVal);
+                    return false;
+                case InternalInterface.MG_ACT_DV_TO_GUI:
+                    await this.handleTransferDataToGui(ctrl);
+                    return false;
+                case InternalInterface.MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER:
+                    await this.fetchRecordsAheadFromServer(ctrl);
+                    break;
+                case InternalInterface.MG_ACT_ENABLE_EVENTS:
+                    this.handleEnableEvents(evt, true);
+                    return false;
+                case InternalInterface.MG_ACT_DISABLE_EVENTS:
+                    this.handleEnableEvents(evt, false);
+                    return false;
+                case InternalInterface.MG_ACT_TASK_PREFIX:
+                    task.setLevel(Constants.TASK_LEVEL_TASK);
+                    break;
+                case InternalInterface.MG_ACT_TASK_SUFFIX:
+                    task.setLevel(Constants.TASK_LEVEL_TASK);
+                    break;
+                case InternalInterface.MG_ACT_REC_PREFIX:
+                    if (task.IsSubForm && task.getParent().InCommonHandlerBeforeRP)
+                        return false;
+                    task.setAfterRetry(ConstInterface.RECOVERY_NONE);
+                    task.DataSynced = false;
+                    if (!task.isStarted())
+                        return false;
+                    if (form.getRowsInPage() > Int32.MinValue && displayLine > Int32.MinValue) {
+                        while (!dv.recExists(displayLine) && displayLine > 0) {
+                            displayLine--;
+                        }
+                        if (displayLine >= 0) {
+                            prevRec = dv.getCurrRec();
+                            let oldTaskMode = task.getMode();
+                            let oldRecId = prevRec.getId();
+                            try {
+                                oldDisplayLine = form.DisplayLine;
+                                form.PrevDisplayLine = oldDisplayLine;
+                                await form.setCurrRowByDisplayLine(displayLine, true, false);
+                                if (prevRec != null && !dv.recExistsById(prevRec.getId())) {
+                                    await form.RefreshDisplay(Constants.TASK_REFRESH_TABLE);
+                                    await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                                }
+                                rec = dv.getCurrRec();
+                            }
+                            catch (e) {
+                                if (e instanceof RecordOutOfDataViewException) {
+                                    if (this._stopExecution) {
+                                        if (oldTaskMode === Constants.TASK_MODE_CREATE && oldDisplayLine > 0 &&
+                                            !dv.recExistsById(oldRecId)) {
+                                            let prevLine = form.getPrevLine(oldDisplayLine);
+                                            await form.restoreOldDisplayLine(prevLine);
+                                        }
+                                        else
+                                            await form.restoreOldDisplayLine(oldDisplayLine);
+                                        await form.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                                        this.setStopExecution(false);
+                                        lastFocusedCtrl = task.getLastParkedCtrl();
+                                        task.getLastParkedCtrl();
+                                        if (lastFocusedCtrl != null)
+                                            await lastFocusedCtrl.invoke();
+                                        this.setStopExecution(true);
+                                        return false;
+                                    }
+                                    else
+                                        Logger.Instance.WriteDevToLog(e.StackTrace);
+                                }
+                                else
+                                    throw e;
+                            }
+                        }
+                        else
+                            throw new ApplicationException('in EventsManager.commonHandlerBefore(): invalid line number: ' +
+                                displayLine);
+                    }
+                    if (rec == null)
+                        throw new ApplicationException('in EventsManager.commonHandlerBefore(): no current record available !');
+                    if (!task.IsInteractive && task.getLevel() === Constants.TASK_LEVEL_TASK)
+                        task.increaseCounter();
+                    if (await task.evalEndCond(ConstInterface.END_COND_EVAL_BEFORE)) {
+                        await task.endTask(true, false, false);
+                        return false;
+                    }
+                    if (form.HasTable())
+                        await form.bringRecordToPage();
+                    if (task.getLevel() !== Constants.TASK_LEVEL_TASK)
+                        return false;
+                    await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                    Logger.Instance.WriteDevToLog('RECORD PREFIX: ' + task.queryTaskPath());
+                    (dv.getCurrRec()).setForceSaveOrg(false);
+                    (dv.getCurrRec()).Synced = false;
+                    dv.saveOriginal();
+                    if (task.IsSubForm && task.PerformParentRecordPrefix) {
+                        let parentTask = task.getParent();
+                        while (parentTask.IsSubForm) {
+                            if (parentTask.getLevel() === Constants.TASK_LEVEL_TASK) {
+                                await this.handleInternalEventWithTask(parentTask, InternalInterface.MG_ACT_REC_PREFIX);
+                                parentTask = parentTask.getParent();
+                                if (this.GetStopExecutionFlag())
+                                    break;
+                            }
+                            else
+                                break;
+                        }
+                    }
+                    task.InCommonHandlerBeforeRP = true;
+                    if (await task.CheckRefreshSubTasks())
+                        await dv.computeSubForms();
+                    task.InCommonHandlerBeforeRP = false;
+                    task.setLevel(Constants.TASK_LEVEL_RECORD);
+                    await task.enableRecordActions();
+                    break;
+                case InternalInterface.MG_ACT_REC_SUFFIX:
+                    let forceSuffix = false;
+                    let isSelectionTable;
+                    task.ConfirmUpdateNo = false;
+                    if (rec == null)
+                        return false;
+                    forceSuffix = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);
+                    if ((rec.Modified || forceSuffix) && rec.getMode() === DataModificationTypes.Delete &&
+                        task.getMode() === Constants.TASK_MODE_DELETE)
+                        return true;
+                    if (task.getLevel() === Constants.TASK_LEVEL_TASK)
+                        return false;
+                    if (task.getLevel() === Constants.TASK_LEVEL_CONTROL) {
+                        task.setInRecordSuffix(true);
+                        await this.handleInternalEventWithMgControlBase(task.getLastParkedCtrl(), InternalInterface.MG_ACT_CTRL_SUFFIX);
+                        task.setInRecordSuffix(false);
+                        if (this._stopExecution)
+                            return false;
+                    }
+                    await task.handleEventOnSlaveTasks(InternalInterface.MG_ACT_REC_SUFFIX);
+                    if (this._stopExecution)
+                        return false;
+                    Logger.Instance.WriteDevToLog('RECORD SUFFIX: ' + task.queryTaskPath());
+                    task.setLevel(Constants.TASK_LEVEL_TASK);
+                    isSelectionTable = await task.checkProp(PropInterface.PROP_TYPE_SELECTION, false);
+                    if (task.getMode() === Constants.TASK_MODE_QUERY && !forceSuffix && !rec.Modified &&
+                        !isSelectionTable)
+                        return false;
+                    if (!rec.Modified && !forceSuffix && (!isSelectionTable || !task.InSelect)) {
+                        if (rec.getMode() === DataModificationTypes.Delete) {
+                            return await this.executeControlVerification(task);
+                        }
+                        return false;
+                    }
+                    if (task.getMode() !== Constants.TASK_MODE_DELETE && rec.Modified) {
+                        if (!await this.updateConfirmed(task))
+                            return false;
+                    }
+                    let stopExecution = !await this.executeControlVerification(task);
+                    if (stopExecution)
+                        return false;
+                    break;
+                case InternalInterface.MG_ACT_CTRL_PREFIX:
+                    if (await this.handleCtrlPrefix(evt))
+                        return true;
+                    else {
+                        evt.Control.InControl = false;
+                        return false;
+                    }
+                case InternalInterface.MG_ACT_CANCEL:
+                    Manager.CleanMessagePane(task);
+                    break;
+                case InternalInterface.MG_ACT_CTRL_SUFFIX:
+                    if (ctrl == null || this.getStopExecutionCtrl() != null)
+                        return false;
+                    if (task.getLevel() !== Constants.TASK_LEVEL_CONTROL)
+                        return false;
+                    if (!ctrl.isSubform()) {
+                        val = Manager.GetCtrlVal(ctrl);
+                        task.CurrentEditingControl = null;
+                        if (!task.cancelWasRaised() &&
+                            (ctrl.Type !== MgControlType.CTRL_TYPE_BROWSER && (!isNullOrUndefined(ctrl._field) && (ctrl._field.getType() === StorageAttribute.DATE || ctrl._field.getType() == StorageAttribute.NUMERIC) || val !== null) && typeof val != 'undefined' &&
+                                !await ctrl.validateAndSetValue(val, true))) {
+                            this.setStopExecution(true);
+                            return false;
+                        }
+                    }
+                    if (!this._stopExecution)
+                        Manager.CleanMessagePane(task);
+                    ctrl.InControl = false;
+                    ctrl.ClipBoardDataExists = false;
+                    ctrl.ValidateControl = true;
+                    ctrl.setInControlSuffix(true);
+                    break;
+            }
+        }
+        return true;
+    }
+    async selectProg(ctrl) {
+        let cmd;
+        let value;
+        let mgVal;
+        let progExecuted = false;
+        let task = ctrl.getForm().getTask();
+        if (ctrl.HasSelectProgram()) {
+            if (ctrl.IsParkable()) {
+                value = Manager.GetCtrlVal(ctrl);
+                if (!ctrl.validateAndSetValue(value, false))
+                    this.setStopExecution(true);
+                else {
+                    let encodedVal = null;
+                    mgVal = await ctrl.getMgValue(value);
+                    var rec = task.DataView.getCurrRec();
+                    encodedVal = rec.getXMLForValue(ctrl.getField().getId(), mgVal);
+                    cmd = CommandFactory.CreateSelectProgramCommand(task.getTaskTag(), null, Int32.MinValue, ctrl.getDitIdx(), encodedVal);
+                    task.getMGData().CmdsToServer.Add(cmd);
+                    let commandsProcessorServer = CommandsProcessorManager.GetCommandsProcessor();
+                    await commandsProcessorServer.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+                    progExecuted = true;
+                }
+            }
+        }
+        return progExecuted;
+    }
+    async executeControlVerification(task) {
+        let table = task.getHandlersTab();
+        for (let i = 0; i < table.getSize(); i++) {
+            let handler = table.getHandler(i);
+            let evt = handler.getEvent();
+            if (evt.getInternalCode() === InternalInterface.MG_ACT_CTRL_VERIFICATION) {
+                let control = ((task.getForm() !== null) ? task.getForm().getCtrlByCtrlName(handler.getCtrlName()) : null);
+                if (!isNullOrUndefined(control)) {
+                    let runTimeEvent = new RunTimeEvent(control);
+                    runTimeEvent.setInternal(InternalInterface.MG_ACT_CTRL_VERIFICATION);
+                    await this.handleEvent(runTimeEvent, false);
+                    if (this._stopExecution) {
+                        LastFocusedManager.setLastFocusedControl(task, control);
+                        this.setStopExecutionCtrl(null);
+                        this.setStopExecutionCtrl(control);
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    async onActSelection(ctrl, form, evt) {
+        let displayLine = evt.getDisplayLine();
+        if (displayLine === Int32.MinValue)
+            displayLine = form.DisplayLine;
+        let simulate = ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_BUTTON || (ctrl.Type === MgControlType.CTRL_TYPE_TAB && !evt.isProduceClick());
+        if (simulate)
+            await this.simulateSelection(ctrl, evt.getValue(), displayLine, evt.isProduceClick());
+        else
+            await this.handleSelection(ctrl, displayLine, evt.getValue());
+    }
+    async onSubformClose(task, evt) {
+        if ((evt.getArgList() != null) && (evt.getArgList().getSize() === 1)) {
+            let subformCtrl = null;
+            let closingSubformName = await evt.getArgList().getArgValue(0, StorageAttribute.ALPHA, 0);
+            if (closingSubformName == null)
+                return;
+            for (let parentTask = task; parentTask.getForm() != null && parentTask.getMgdID() === task.getMgdID(); parentTask = parentTask.getParent()) {
+                subformCtrl = parentTask.getForm().getCtrlByName(closingSubformName.trim(), MgControlType.CTRL_TYPE_SUBFORM);
+                if (subformCtrl != null) {
+                    let subformTask = subformCtrl.getSubformTask();
+                    if (subformTask != null && !subformTask.IsRoute()) {
+                        {
+                            await this.performSubformClose(subformCtrl);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    async performSubformClose(subformCtrl) {
+        let subformTask = subformCtrl.getSubformTask();
+        let parentTask = subformCtrl.getForm().getTask();
+        let mgd = subformTask.getMGData();
+        this.pushNewExecStacks();
+        await subformTask.endTask(true, false, false, true);
+        this.popNewExecStacks();
+        if (!this._stopExecution) {
+            parentTask.TaskService.RemoveRecomputes(parentTask);
+            await subformTask.stop();
+            subformCtrl.resetSubformTask();
+            await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+            Commands.addClosesubform(CommandType.CLOSE_SUB_FORM, subformCtrl, subformTask.getTaskTag(), subformCtrl.getName(), subformTask.getForm().buildFormName());
+            if (subformCtrl.IsModal())
+                mgd.abort();
+        }
+    }
+    createEventArguments(evt) {
+        if (evt.getArgList() === null) {
+            if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {
+                switch (evt.getInternalCode()) {
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+    async DoTaskLevelRecordSuffix(task, refDoSuffix) {
+        let shouldReturn = false;
+        if (task.getLevel() === Constants.TASK_LEVEL_RECORD) {
+            refDoSuffix.value = false;
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+            if (this.GetStopExecutionFlag())
+                shouldReturn = true;
+        }
+        return shouldReturn;
+    }
+    async DoTaskLevelRecordPrefix(task) {
+        if (!this.GetStopExecutionFlag()) {
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+        }
+    }
+    async commonHandler(evt) {
+        let task = evt.getTask();
+        let mgData = task.getMGData();
+        let form = task.getForm();
+        let ctrl = evt.Control;
+        let lastParkedCtrl;
+        let doSuffix = true;
+        let oldMode;
+        let server = Task.CommandsProcessor;
+        if (this._stopExecution)
+            return;
+        if (evt.getType() === ConstInterface.EVENT_TYPE_USER)
+            evt = new RunTimeEvent(evt.getUserEvent(), evt);
+        try {
+            this.pushRtEvent(evt);
+            if (evt.getType() === ConstInterface.EVENT_TYPE_SYSTEM) {
+                let actId = this.getMatchingAction(evt.getKbdItm());
+                if (actId !== 0) {
+                    evt = new RunTimeEvent(evt, evt);
+                    evt.setInternal(actId);
+                    evt.setArgList(null);
+                }
+            }
+            let cmd;
+            if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && !evt.isImmediate() && this.ActAllowed(evt.getInternalCode()) && !this._processingTopMostEndTask) {
+                let cmdsToServer = mgData.CmdsToServer;
+                let dv = task.DataView;
+                let rec = dv.getCurrRec();
+                let intEvtCode = evt.getInternalCode();
+                switch (intEvtCode) {
+                    case InternalInterface.MG_ACT_SUBFORM_CLOSE:
+                        await this.onSubformClose(task, evt);
+                        break;
+                    case InternalInterface.MG_ACT_BUTTON:
+                    case InternalInterface.MG_ACT_CTRL_HIT:
+                        if (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON &&
+                            (intEvtCode === InternalInterface.MG_ACT_BUTTON || !evt.isGuiTriggeredEvent() || ctrl.isParkable(true))) {
+                            let aRtEvt = new RunTimeEvent(ctrl);
+                            if (ctrl.getRtEvtTask() != null)
+                                aRtEvt.setTask(ctrl.getRtEvtTask());
+                            if (ConstInterface.EVENT_TYPE_NONE !== aRtEvt.getType()) {
+                                if (ctrl.useZoomHandler()) {
+                                    let taskToEnable = aRtEvt.getTask();
+                                    if (taskToEnable != null)
+                                        taskToEnable.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);
+                                }
+                                aRtEvt.setArgList(ctrl.ArgList);
+                                await aRtEvt.setPublicName();
+                                this.addToTail(aRtEvt);
+                                this.checkAndSaveRouteEventIfCtxRemovedFromSrvr(aRtEvt);
+                            }
+                        }
+                        else if (ctrl.Type === MgControlType.CTRL_TYPE_TAB) {
+                            this.addInternalEventWithCtrlAndCode(ctrl, InternalInterface.MG_ACT_ZOOM);
+                        }
+                        else if (ctrl.Type === MgControlType.CTRL_TYPE_RADIO) {
+                            ctrl.setControlToFocus();
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_TOGGLE_INSERT:
+                        RuntimeContextBase.Instance.ToggleInsertMode();
+                        break;
+                    case InternalInterface.MG_ACT_CLOSE:
+                        let rtEvt = new RunTimeEvent(evt, evt);
+                        rtEvt.setInternal(InternalInterface.MG_ACT_EXIT);
+                        this.addToTail(rtEvt);
+                        break;
+                    case InternalInterface.MG_ACT_EXIT:
+                        let taskToEnd = (task.isMainProg() ? MGDataCollection.Instance.StartupMgData.getFirstTask() : task);
+                        await taskToEnd.endTask(evt.reversibleExit(), false, evt.ExitDueToError());
+                        break;
+                    case InternalInterface.MG_ACT_EXIT_SYSTEM:
+                        await MGDataCollection.Instance.StartupMgData.getFirstTask().endTask(evt.reversibleExit(), false, false);
+                        break;
+                    case InternalInterface.MG_ACT_TBL_NXTLINE:
+                        if (form != null)
+                            await form.moveInView(Constants.MOVE_UNIT_ROW, Constants.MOVE_DIRECTION_NEXT);
+                        break;
+                    case InternalInterface.MG_ACT_TBL_PRVLINE:
+                        if (form != null)
+                            await form.moveInView(Constants.MOVE_UNIT_ROW, Constants.MOVE_DIRECTION_PREV);
+                        break;
+                    case InternalInterface.MG_ACT_TBL_NXTPAGE:
+                        if (form != null)
+                            await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_NEXT);
+                        break;
+                    case InternalInterface.MG_ACT_TBL_PRVPAGE:
+                        if (form != null)
+                            await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_PREV);
+                        break;
+                    case InternalInterface.MG_ACT_TBL_BEGPAGE:
+                        if (form != null)
+                            await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_BEGIN);
+                        break;
+                    case InternalInterface.MG_ACT_TBL_ENDPAGE:
+                        if (form != null)
+                            await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_END);
+                        break;
+                    case InternalInterface.MG_ACT_TBL_BEGTBL:
+                        lastParkedCtrl = task.getLastParkedCtrl();
+                        if (lastParkedCtrl == null || !lastParkedCtrl.isListBox()) {
+                            if (form != null)
+                                await form.moveInView(Constants.MOVE_UNIT_TABLE, Constants.MOVE_DIRECTION_BEGIN);
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_TBL_ENDTBL:
+                        lastParkedCtrl = task.getLastParkedCtrl();
+                        if (lastParkedCtrl === null || !lastParkedCtrl.isListBox()) {
+                            if (form != null)
+                                await form.moveInView(Constants.MOVE_UNIT_TABLE, Constants.MOVE_DIRECTION_END);
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_WEB_ON_DBLICK:
+                        {
+                            let ctrlType = ctrl.Type;
+                            let putAction = InternalInterface.MG_ACT_NONE;
+                            if (ctrlType !== MgControlType.CTRL_TYPE_TABLE && ctrlType !== MgControlType.CTRL_TYPE_LABEL &&
+                                ctrlType !== MgControlType.CTRL_TYPE_IMAGE) {
+                                if (ctrl.getForm().getTask().ActionManager.isEnabled(InternalInterface.MG_ACT_SELECT))
+                                    putAction = InternalInterface.MG_ACT_SELECT;
+                                else {
+                                    if (ctrl.getForm().getTask().ActionManager.isEnabled(InternalInterface.MG_ACT_ZOOM))
+                                        putAction = InternalInterface.MG_ACT_ZOOM;
+                                }
+                                if (putAction !== InternalInterface.MG_ACT_NONE)
+                                    this.addInternalEventWithCtrlAndCode(ctrl, putAction);
+                            }
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_DELLINE:
+                        if (await this.HandleActionDelline(task, dv, rec, false))
+                            return;
+                        break;
+                    case InternalInterface.MG_ACT_CRELINE:
+                    case InternalInterface.MG_ACT_CRELINE_ABOVE:
+                        if (task.DataView.isEmptyDataview()) {
+                            await this.gotoCreateMode(task);
+                            break;
+                        }
+                        if (task.getInCreateLine())
+                            break;
+                        task.setInCreateLine(true);
+                        try {
+                            if (task.getLevel() === Constants.TASK_LEVEL_CONTROL) {
+                                await this.handleInternalEventWithMgControlBase(task.getLastParkedCtrl(), InternalInterface.MG_ACT_CTRL_SUFFIX);
+                                if (this.GetStopExecutionFlag())
+                                    return;
+                            }
+                            if (task.getMode() === Constants.TASK_MODE_CREATE && rec != null && !rec.Modified) {
+                                if (await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false)) {
+                                    doSuffix = false;
+                                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                                    if (this.GetStopExecutionFlag() || task.isAborting())
+                                        return;
+                                }
+                                else {
+                                    task.setLevel(Constants.TASK_LEVEL_TASK);
+                                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                                    if (!this.GetStopExecutionFlag() && form != null) {
+                                        let lastParkedControl = task.getLastParkedCtrl();
+                                        if (lastParkedControl !== null)
+                                            await lastParkedControl.invoke();
+                                    }
+                                    return;
+                                }
+                            }
+                            let refDoSuffix = new RefParam(doSuffix);
+                            if (await this.DoTaskLevelRecordSuffix(task, refDoSuffix))
+                                return;
+                            doSuffix = refDoSuffix.value;
+                            if (form != null) {
+                                if ((task.getMode() !== Constants.TASK_MODE_CREATE) || !task.ConfirmUpdateNo)
+                                    await form.addRec(doSuffix, intEvtCode == InternalInterface.MG_ACT_CRELINE_ABOVE ? true : false);
+                            }
+                            await this.DoTaskLevelRecordPrefix(task);
+                            await this.HandleActEnterRowEditing(task);
+                        }
+                        finally {
+                            task.setInCreateLine(false);
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_CANCEL:
+                        await this.HandleActCancel(evt, task, form, ctrl, rec, true);
+                        break;
+                    case InternalInterface.MG_ACT_ENTER_ROW_EDITING:
+                        await this.HandleActEnterRowEditing(task);
+                        break;
+                    case InternalInterface.MG_ACT_RT_QUIT:
+                        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_RT_QUIT);
+                        break;
+                    case InternalInterface.MG_ACT_RTO_CREATE:
+                        if (task.getMode() === Constants.TASK_MODE_CREATE ||
+                            await (task.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean()) {
+                            await this.gotoCreateMode(task);
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_RTO_QUERY:
+                        if (task.getMode() !== Constants.TASK_MODE_QUERY &&
+                            (await (task.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean()) === false)
+                            break;
+                        await task.enableModes();
+                        oldMode = task.getOriginalTaskMode();
+                        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                        if (!this.GetStopExecutionFlag()) {
+                            task.setMode(Constants.TASK_MODE_QUERY);
+                            if (oldMode !== Constants.TASK_MODE_CREATE) {
+                                await dv.currRecCompute(true);
+                                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                                if (ctrl != null)
+                                    await ctrl.invoke();
+                                await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                            }
+                            else {
+                                task.setPreventRecordSuffix(true);
+                                task.setPreventControlChange(true);
+                                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_RT_REFRESH_VIEW);
+                                if (ctrl != null)
+                                    await ctrl.invoke();
+                                task.setPreventRecordSuffix(false);
+                                task.setPreventControlChange(false);
+                                if (!dv.isEmpty() && (dv.getCurrRec()).getMode() !== DataModificationTypes.Insert)
+                                    task.setMode(Constants.TASK_MODE_QUERY);
+                                else
+                                    task.setMode(Constants.TASK_MODE_CREATE);
+                                await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                            }
+                            task.setOriginalTaskMode(Constants.TASK_MODE_QUERY);
+                            await task.setCreateDeleteActsEnableState();
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_RTO_MODIFY:
+                        if (task.getMode() !== Constants.TASK_MODE_MODIFY &&
+                            (await (task.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean()) === false)
+                            break;
+                        await task.enableModes();
+                        oldMode = task.getOriginalTaskMode();
+                        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                        if (!this.GetStopExecutionFlag()) {
+                            task.setMode(Constants.TASK_MODE_MODIFY);
+                            if (oldMode !== Constants.TASK_MODE_CREATE) {
+                                await dv.currRecCompute(true);
+                                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                                if (ctrl != null)
+                                    await ctrl.invoke();
+                            }
+                            else {
+                                task.setPreventRecordSuffix(true);
+                                task.setPreventControlChange(true);
+                                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_RT_REFRESH_VIEW);
+                                if (ctrl != null)
+                                    await ctrl.invoke();
+                                task.setPreventRecordSuffix(false);
+                                task.setPreventControlChange(false);
+                                if (!dv.isEmpty() && (dv.getCurrRec()).getMode() !== DataModificationTypes.Insert)
+                                    task.setMode(Constants.TASK_MODE_MODIFY);
+                                else
+                                    task.setMode(Constants.TASK_MODE_CREATE);
+                                await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                            }
+                            task.setOriginalTaskMode(Constants.TASK_MODE_MODIFY);
+                            await task.setCreateDeleteActsEnableState();
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_SELECT:
+                        try {
+                            task.InSelect = true;
+                            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                        }
+                        finally {
+                            task.InSelect = false;
+                        }
+                        if (!this._stopExecution) {
+                            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_EXIT);
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_SUBFORM_REFRESH:
+                        if ((evt.getArgList() != null) && (evt.getArgList().getSize() === 1)) {
+                            let subformCtrl = null;
+                            let RefreshedSubformName = await evt.getArgList().getArgValue(0, StorageAttribute.ALPHA, 0);
+                            if (RefreshedSubformName == null)
+                                break;
+                            for (let parentTask = task; parentTask.getForm() != null && parentTask.getMgdID() === task.getMgdID(); parentTask = parentTask.getParent()) {
+                                subformCtrl = parentTask.getForm().getCtrlByName(RefreshedSubformName.trim(), MgControlType.CTRL_TYPE_SUBFORM);
+                                if (subformCtrl != null) {
+                                    let subformTask = subformCtrl.getSubformTask();
+                                    if (subformTask == null) {
+                                        if (await (subformCtrl.getProp(PropInterface.PROP_TYPE_SUBFORM_TYPE)).getValueInt() !== SubformType.None)
+                                            await this.OpenSubform(parentTask, subformCtrl);
+                                    }
+                                    else
+                                        await parentTask.SubformRefresh(subformTask, true);
+                                    break;
+                                }
+                            }
+                        }
+                        else if ((evt.getArgList() != null) && (evt.getArgList().getSize() === 2)) {
+                            let subformTask = task, parentTask;
+                            let taskTag = await evt.getArgList().getArgValue(1, StorageAttribute.NUMERIC, 0);
+                            while (subformTask.IsSubForm) {
+                                parentTask = subformTask.getParent();
+                                if (subformTask.getTaskTag() === taskTag) {
+                                    await parentTask.SubformRefresh(subformTask, true);
+                                    break;
+                                }
+                                subformTask = parentTask;
+                            }
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_SUBFORM_OPEN:
+                        await this.OpenSubform(task, evt.Control);
+                        break;
+                    case InternalInterface.MG_ACT_RTO_SEARCH:
+                        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                        if (!this.GetStopExecutionFlag()) {
+                            cmd = CommandFactory.CreateEventCommand(task.getTaskTag(), intEvtCode);
+                            task.getTaskCache().clearCache();
+                            await task.DataviewManager.Execute(cmd);
+                            if (!form.isScreenMode()) {
+                                dv.setTopRecIdx(0);
+                                if (form.HasTable()) {
+                                    await form.restoreOldDisplayLine(form.recordIdx2DisplayLine(dv.getCurrRecIdx()));
+                                }
+                            }
+                            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                            if (ctrl != null)
+                                await ctrl.invoke();
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_RT_REFRESH_SCREEN:
+                    case InternalInterface.MG_ACT_RT_REFRESH_VIEW:
+                    case InternalInterface.MG_ACT_RT_REFRESH_RECORD:
+                        await this.handleRefreshEvents(evt);
+                        break;
+                    case InternalInterface.MG_ACT_ACT_CLOSE_APPL:
+                        cmd =
+                            CommandFactory.CreateEventCommand(MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag(), InternalInterface.MG_ACT_BROWSER_ESC);
+                        cmdsToServer.Add(cmd);
+                        await server.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+                        break;
+                    case InternalInterface.MG_ACT_CONTEXT_REMOVE:
+                        let currRecord = LastFocusedManager.Instance.getLastFocusedTask().DataView.getCurrRec();
+                        if (ClientManager.TransCacheExists() || (currRecord != null && currRecord.Modified)) {
+                            console.log('Pending transaction/record is modified, discarded \'Context Remove\' event.');
+                        }
+                        else {
+                            if (Environment.Instance.getClientContextInactivityTimeout() > 0) {
+                                await this.ExecuteClientContextInactivityTimer();
+                            }
+                            if (!EventsManager.clientContextInactivityTimerAborted) {
+                                let contextTerminationEventCommand = CommandFactory.CreateContextTerminationEventCommand(MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag());
+                                MGDataCollection.Instance.getCurrMGData().CmdsToServer.Add(contextTerminationEventCommand);
+                                RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);
+                                console.log('Removed context from server');
+                                RuntimeContextBase.Instance.RemovingContextFromServer = true;
+                            }
+                            else {
+                                console.log('Discarded \'Context Remove\' event as user event occurred.');
+                                EventsManager.clientContextInactivityTimerAborted = false;
+                                break;
+                            }
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_SERVER_TERMINATION:
+                    case InternalInterface.MG_ACT_DUMP_ENVIRONMENT:
+                        cmd = CommandFactory.CreateEventCommand(task.getTaskTag(), intEvtCode);
+                        cmdsToServer.Add(cmd);
+                        await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+                        break;
+                    case InternalInterface.MG_ACT_RT_EDT_NULL:
+                        if (this._currField != null && this._currField.NullAllowed) {
+                            await this._currField.setValueAndStartRecompute(this._currField.getMagicDefaultValue(), true, true, true, false);
+                            await this._currField.updateDisplay();
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_ROLLBACK:
+                        await EventsManager.HandleRollbackAction(task, cmdsToServer, RollbackEventCommand_RollbackType.ROLLBACK);
+                        break;
+                    case InternalInterface.MG_ACT_OK:
+                    case InternalInterface.MG_ACT_INDEX_CHANGE:
+                    case InternalInterface.MG_ACT_COL_SORT:
+                        if ((intEvtCode === InternalInterface.MG_ACT_INDEX_CHANGE && task.DataviewManager.HasRemoteData) ||
+                            (intEvtCode === InternalInterface.MG_ACT_COL_SORT && ctrl.getField() != null)) {
+                            let lastFocusedTask = LastFocusedManager.Instance.getLastFocusedTask();
+                            let focusedCtrl = LastFocusedManager.getLastFocusedControl(LastFocusedManager.LastFocusMgdID);
+                            if (focusedCtrl != null)
+                                await this.handleInternalEventWithMgControlBase(focusedCtrl, InternalInterface.MG_ACT_CTRL_SUFFIX);
+                            if (!this.GetStopExecutionFlag())
+                                await task.ExecuteNestedRS(lastFocusedTask);
+                            if (!this.GetStopExecutionFlag() && task.getLevel() !== Constants.TASK_LEVEL_TASK)
+                                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                            if (!this.GetStopExecutionFlag()) {
+                                task.getTaskCache().clearCache();
+                                if (intEvtCode === InternalInterface.MG_ACT_INDEX_CHANGE) {
+                                    let taskForm = task.getForm();
+                                    if (taskForm.HasTable())
+                                        form.clearTableColumnSortMark(true);
+                                    cmd = await CommandFactory.CreateIndexChangeCommand(task.getTaskTag(), task.DataView.GetCurrentRecId(), evt.getArgList());
+                                }
+                                else {
+                                    cmd = CommandFactory.CreateColumnSortCommand(task.getTaskTag(), evt.Direction, ctrl.getDitIdx(), ctrl.getField().getId(), task.DataView.GetCurrentRecId());
+                                }
+                                await task.DataviewManager.Execute(cmd);
+                                dv.setTopRecIdx(0);
+                                await form.restoreOldDisplayLine(0);
+                                if (!(task === LastFocusedManager.Instance.getLastFocusedTask() || !task.pathContains(LastFocusedManager.Instance.getLastFocusedTask()))) {
+                                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                                    if (!this.GetStopExecutionFlag() && !task.getPreventControlChange())
+                                        await lastFocusedTask.ExecuteNestedRS(task);
+                                    if (!this.GetStopExecutionFlag() && focusedCtrl != null)
+                                        await focusedCtrl.invoke();
+                                }
+                                else
+                                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                            }
+                        }
+                        break;
+                    case InternalInterface.MG_ACT_COL_CLICK:
+                        if (!this.GetStopExecutionFlag() && evt.isGuiTriggeredEvent() && ctrl.isColumnSortable()) {
+                            let columnChildControl = ctrl.getColumnChildControl();
+                            if (columnChildControl != null) {
+                                let aRtEvt = new RunTimeEvent(columnChildControl, evt.Direction, 0);
+                                aRtEvt.setInternal(InternalInterface.MG_ACT_COL_SORT);
+                                this.addToTail(aRtEvt);
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+        finally {
+            this.popRtEvent();
+        }
+    }
+    async HandleActEnterRowEditing(task) {
+        if (task.getMode() === Constants.TASK_MODE_QUERY)
+            task.WriteToMessagePane(`Cannot enter Row Editing when in Query Mode.`);
+        else {
+            let myform = task.getForm();
+            await myform.startRowEditing(myform.DisplayLine);
+        }
+    }
+    async HandleStopRowEditing(task) {
+        let myform = task.getForm();
+        await myform.stopRowEditing(myform.DisplayLine);
+    }
+    async OpenSubform(task, subformControl) {
+        task.TaskService.RemoveRecomputes(task);
+        let cmd = CommandFactory.CreateSubformOpenCommand(task.getTaskTag(), subformControl.getDitIdx());
+        task.getMGData().CmdsToServer.Add(cmd);
+        await Task.CommandsProcessor.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+    }
+    static async HandleRollbackAction(task, cmdsToServer, rollbackType) {
+        let commandsProcessor = Task.CommandsProcessor;
+        ClientRefreshCommand.ClientIsInRollbackCommand = true;
+        task = task.TaskService.GetOwnerTransactionTask(task);
+        let cmd = CommandFactory.CreateRollbackEventCommand(task.getTaskTag(), rollbackType);
+        cmdsToServer.Add(cmd);
+        await commandsProcessor.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+        ClientRefreshCommand.ClientIsInRollbackCommand = false;
+    }
+    async HandleActCancel(evt, task, form, ctrl, rec, isMG_ACT_CANCEL) {
+        if (task.InHandleActCancel)
+            return;
+        task.InHandleActCancel = true;
+        let oldMode = task.getMode();
+        let saveDisplayLine = task.getForm().DisplayLine;
+        if (oldMode !== Constants.TASK_MODE_QUERY && !rec.Updated) {
+            if (isMG_ACT_CANCEL) {
+                if (rec.Modified || (task.getLastParkedCtrl() !== null && task.getLastParkedCtrl().ModifiedByUser)) {
+                    if (await task.checkProp(PropInterface.PROP_TYPE_CONFIRM_CANCEL, false)) {
+                        let confirmed = await GUIManager.Instance.confirm_bool(MsgInterface.CONFIRM_STR_CANCEL);
+                        if (!confirmed) {
+                            task.InHandleActCancel = false;
+                            return;
+                        }
+                    }
+                }
+            }
+            let oldRecMode = rec.getMode();
+            if (GuiEnvironment.Environment.GetSpecialCancelOnCreate() && task.getMode() == Constants.TASK_MODE_CREATE
+                && task.getOriginalTaskMode() == Constants.TASK_MODE_CREATE) {
+                let enable = await task.checkProp(PropInterface.PROP_TYPE_ALLOW_MODIFY, true);
+                if (enable) {
+                    let allowEmptyDataView = await task.checkProp(PropInterface.PROP_TYPE_ALLOW_EMPTY_DATAVIEW, true);
+                    if (task.DataView.getSize() == 1 && allowEmptyDataView) {
+                        task.setMode('M');
+                        task.DataView.setEmptyDataview(true);
+                    }
+                }
+            }
+            if (isMG_ACT_CANCEL) {
+                if (task.isTransactionOnLevel(ConstInterface.TRANS_RECORD_PREFIX) && evt.RollbackInCancel()) {
+                    await EventsManager.HandleRollbackAction(task, task.getMGData().CmdsToServer, RollbackEventCommand_RollbackType.CANCEL);
+                }
+            }
+            await EventsManager.HandleCancelEdit(evt, task, form, rec, oldRecMode);
+        }
+        else {
+            task.setLevel(Constants.TASK_LEVEL_TASK);
+            let lastFocusedControl = LastFocusedManager.getLastFocusedControl();
+            if (lastFocusedControl !== null) {
+                lastFocusedControl.getForm().getTask().setLevel(Constants.TASK_LEVEL_TASK);
+            }
+            if (!evt.isQuit()) {
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                await this.HandleParkabilityOnRowChange(task);
+            }
+        }
+        if (evt.isQuit())
+            await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_EXIT);
+        await form.stopRowEditing(saveDisplayLine);
+        task.InHandleActCancel = false;
+    }
+    static async HandleCancelEdit(evt, task, form, rec, oldRecMode) {
+        if (rec.Synced && oldRecMode === DataModificationTypes.Insert)
+            rec.setMode(oldRecMode);
+        if (form !== null) {
+            if (task.getLastParkedCtrl() !== null)
+                task.getLastParkedCtrl().resetPrevVal();
+            await form.cancelEdit(true, evt.isQuit());
+        }
+    }
+    async HandleActionDelline(task, dv, rec, nonInteractiveDelete) {
+        let lastParkedCtrl;
+        let myform = task.getForm();
+        let saveIsRowEditing = myform.getIsRowEditingFromGui(myform.DisplayLine);
+        let oldRecMode;
+        if (await task.checkProp(PropInterface.PROP_TYPE_ALLOW_DELETE, true)) {
+            lastParkedCtrl = task.getLastParkedCtrl();
+            if (lastParkedCtrl !== null)
+                await this.handleInternalEventWithMgControlBase(lastParkedCtrl, InternalInterface.MG_ACT_CTRL_SUFFIX);
+            if (!this.GetStopExecutionFlag()) {
+                oldRecMode = rec.getMode();
+                rec.clearMode();
+                rec.setMode(DataModificationTypes.Delete);
+                if (oldRecMode === DataModificationTypes.Insert)
+                    rec.setSendToServer(false);
+                if (rec.Modified || await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false)) {
+                    task.setMode(Constants.TASK_MODE_MODIFY);
+                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                    if (this._stopExecution) {
+                        if (!rec.SendToServer) {
+                            await dv.addCurrToModified();
+                            rec.setSendToServer(true);
+                        }
+                        rec.clearMode();
+                        rec.setMode(oldRecMode);
+                        this.setStopExecution(false);
+                        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                        this.setStopExecution(true);
+                        return true;
+                    }
+                }
+                rec.setInDeleteProcess(true);
+                task.setMode(Constants.TASK_MODE_DELETE);
+                let skipConfirmDialog = nonInteractiveDelete;
+                if (!skipConfirmDialog) {
+                    if (task.mustConfirmInDeleteMode() || await task.checkProp(PropInterface.PROP_TYPE_CONFIRM_UPDATE, false)) {
+                        let confirmed = await GUIManager.Instance.confirm_bool(MsgInterface.CONFIRM_STR_DELETE);
+                        if (!confirmed) {
+                            rec.clearMode();
+                            rec.setMode(oldRecMode);
+                            task.setMode(Constants.TASK_MODE_MODIFY);
+                            if (lastParkedCtrl !== null)
+                                await this.handleInternalEventWithMgControlBase(lastParkedCtrl, InternalInterface.MG_ACT_CTRL_PREFIX);
+                            if (saveIsRowEditing) {
+                                let myform = task.getForm();
+                                await myform.startRowEditing(myform.DisplayLine);
+                            }
+                            return true;
+                        }
+                    }
+                }
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                rec.setInDeleteProcess(false);
+                if (this._stopExecution) {
+                    if (!rec.SendToServer) {
+                        await dv.addCurrToModified();
+                        rec.setSendToServer(true);
+                    }
+                    rec.clearMode();
+                    rec.setMode(oldRecMode);
+                    this.setStopExecution(false);
+                    task.setMode(Constants.TASK_MODE_MODIFY);
+                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                    this.setStopExecution(true);
+                    return true;
+                }
+                if (oldRecMode === DataModificationTypes.Insert) {
+                    rec.clearMode();
+                    rec.setMode(oldRecMode);
+                }
+                let newCurrRec = dv.getCurrRec();
+                try {
+                    if (rec !== newCurrRec)
+                        await dv.setCurrRec(rec.getId(), false);
+                    if (!task.isAborting())
+                        await this.delCurrRec(task, false);
+                }
+                finally {
+                    if (rec !== newCurrRec) {
+                        await dv.setCurrRec(newCurrRec.getId(), false);
+                        if (dv.getSize() === 1)
+                            task.setMode(Constants.TASK_MODE_CREATE);
+                    }
+                    if (nonInteractiveDelete)
+                        task.setMode(Constants.TASK_MODE_DELETE);
+                }
+            }
+        }
+        return false;
+    }
+    async handleRefreshEvents(evt) {
+        let task = evt.getTask();
+        let form = task.getForm();
+        let dv = task.DataView;
+        let intEvtCode = evt.getInternalCode();
+        let cmd = null;
+        if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_RECORD)
+            this._isInRecordFlushEvent = true;
+        if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_VIEW && task.getMode() === Constants.TASK_MODE_CREATE && !await task.checkProp(PropInterface.PROP_TYPE_ALLOW_MODIFY, true)) {
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_EXIT);
+        }
+        else {
+            await task.ExecuteNestedRS(LastFocusedManager.Instance.getLastFocusedTask());
+            if (!this.GetStopExecutionFlag()) {
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+            }
+            if (!this.GetStopExecutionFlag() && !task.InEndTask && !task.isAborting()) {
+                if (intEvtCode !== InternalInterface.MG_ACT_RT_REFRESH_SCREEN) {
+                    let currentRow = 0;
+                    if (!evt.getRefreshType()) {
+                        if (evt.RtViewRefreshUseCurrentRow() && task.IsInteractive) {
+                            currentRow = form.getCurrRecPosInForm();
+                        }
+                        cmd = CommandFactory.CreateInternalRefreshCommand(task.getTaskTag(), intEvtCode, dv.CurrentRecId, currentRow);
+                    }
+                    else {
+                        if (task.IsInteractive)
+                            currentRow = form.getCurrRecPosInForm();
+                        let refetchRecord = true;
+                        if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_RECORD && evt.getArgList() !== null && evt.getArgList().getSize() !== 0) {
+                            let refetchRecStr;
+                            refetchRecStr = await evt.getArgList().getArgValue(0, StorageAttribute.BOOLEAN, 0);
+                            refetchRecord = (isNullOrUndefined(refetchRecStr) || refetchRecStr === '1');
+                        }
+                        if (refetchRecord)
+                            cmd = await CommandFactory.CreateRealRefreshCommand(task.getTaskTag(), intEvtCode, currentRow, evt.getArgList(), dv.CurrentRecId);
+                    }
+                }
+                else {
+                    let id;
+                    if (task.getForm() === null)
+                        id = 0;
+                    else if (task.getForm().isScreenMode())
+                        id = (task.DataView.getCurrRec()).getId();
+                    else
+                        id = task.DataView.getRecByIdx(task.DataView.getTopRecIdx()).getId();
+                    cmd = CommandFactory.CreateScreenRefreshCommand(task.getTaskTag(), id, dv.CurrentRecId);
+                }
+                if (intEvtCode !== InternalInterface.MG_ACT_RT_REFRESH_SCREEN)
+                    task.getTaskCache().clearCache();
+                if (cmd !== null)
+                    await task.DataviewManager.Execute(cmd);
+                this._isInRecordFlushEvent = false;
+                if (!this.GetStopExecutionFlag() && !task.InEndTask && !task.isAborting()) {
+                    if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_VIEW && !form.isScreenMode()) {
+                        dv.setTopRecIdx(0);
+                        if (form.HasTable()) {
+                            form.clearTableColumnSortMark(true);
+                            await form.restoreOldDisplayLine(form.recordIdx2DisplayLine(dv.getCurrRecIdx()));
+                        }
+                    }
+                    if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_RECORD && task.getMode() !== Constants.TASK_MODE_QUERY && !task.getAfterRetry()) {
+                        if (task.getMode() === Constants.TASK_MODE_CREATE) {
+                            task.setMode(Constants.TASK_MODE_MODIFY);
+                            (task.DataView.getCurrRec()).setOldRec();
+                        }
+                        await dv.currRecCompute(true);
+                    }
+                    else if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_SCREEN && task.getMode() !== Constants.TASK_MODE_QUERY && !task.getAfterRetry()) {
+                        await dv.currRecCompute(true);
+                    }
+                    this.setIsInViewRefresh(true);
+                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                    if (!this.GetStopExecutionFlag() && !task.getPreventControlChange()) {
+                        if (!(task === LastFocusedManager.Instance.getLastFocusedTask() || !task.pathContains(LastFocusedManager.Instance.getLastFocusedTask())))
+                            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                    }
+                }
+            }
+        }
+    }
+    async gotoCreateMode(task) {
+        let cmd;
+        await task.enableModes();
+        await task.ExecuteNestedRS(LastFocusedManager.Instance.getLastFocusedTask());
+        if (!this.GetStopExecutionFlag())
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+        if (!this.GetStopExecutionFlag()) {
+            cmd = CommandFactory.CreateEventCommand(task.getTaskTag(), InternalInterface.MG_ACT_RTO_CREATE);
+            await task.DataviewManager.Execute(cmd);
+            if (task.getLevel() === Constants.TASK_LEVEL_TASK)
+                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+            await this.HandleNonParkableControls(task);
+            await task.setCreateDeleteActsEnableState();
+            task.setOriginalTaskMode(Constants.TASK_MODE_CREATE);
+            await this.HandleActEnterRowEditing(task);
+        }
+    }
+    async commonHandlerAfter(evt, rcBefore) {
+        let task = evt.getTask();
+        let dv;
+        let rec = null;
+        let ctrl;
+        let recModified = false;
+        let recModeIsDelete = false;
+        let forceSuffix;
+        if (this._stopExecution && evt.getInternalCode() !== InternalInterface.MG_ACT_REC_SUFFIX && evt.getInternalCode() !== InternalInterface.MG_ACT_CTRL_SUFFIX)
+            return;
+        if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {
+            dv = task.DataView;
+            rec = dv.getCurrRec();
+            ctrl = evt.Control;
+            switch (evt.getInternalCode()) {
+                case InternalInterface.MG_ACT_REC_PREFIX:
+                    if (rcBefore) {
+                        if (await task.CheckRefreshSubTasks())
+                            await task.doSubformRecPrefixSuffix();
+                        await task.handleEventOnSlaveTasks(InternalInterface.MG_ACT_REC_PREFIX);
+                        await task.enableModes();
+                    }
+                    break;
+                case InternalInterface.MG_ACT_REC_SUFFIX:
+                    task.isFirstRecordCycle(false);
+                    if (task.getPreventRecordSuffix()) {
+                        task.setPreventRecordSuffix(false);
+                        return;
+                    }
+                    task.DoSubformPrefixSuffix = false;
+                    if (this._stopExecution) {
+                        if (rec.getMode() === DataModificationTypes.Delete)
+                            rec.clearMode();
+                        if (task.getLevel() !== Constants.TASK_LEVEL_CONTROL) {
+                            let last = this.getStopExecutionCtrl();
+                            if (last === null)
+                                last = task.getLastParkedCtrl();
+                            this.setStopExecution(false);
+                            this.setStopExecutionCtrl(null);
+                            if (last != null) {
+                                task.setLevel(Constants.TASK_LEVEL_RECORD);
+                                let inCtrlPrefix = task.InCtrlPrefix;
+                                task.InCtrlPrefix = false;
+                                await this.handleInternalEventWithMgControlBase(last, InternalInterface.MG_ACT_CTRL_PREFIX);
+                                task.InCtrlPrefix = inCtrlPrefix;
+                            }
+                            this.setStopExecution(true);
+                        }
+                        return;
+                    }
+                    else {
+                        await this.HandleStopRowEditing(task);
+                    }
+                    if (rec != null) {
+                        recModified = rec.Modified;
+                        if (!this._stopExecution && rec.isCauseInvalidation()) {
+                            task.getForm().invalidateTable();
+                            rec.setCauseInvalidation(false);
+                        }
+                        recModeIsDelete = (rec.getMode() === DataModificationTypes.Delete);
+                        forceSuffix = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);
+                        if (recModeIsDelete && task.getMode() === Constants.TASK_MODE_DELETE ||
+                            !recModeIsDelete && !rec.inDeleteProcess() && (recModified || forceSuffix)) {
+                            rec.setMode(DataModificationTypes.Update);
+                            await dv.addCurrToModified();
+                            dv.setChanged(true);
+                            if (recModified && task.getMode() === Constants.TASK_MODE_QUERY) {
+                                if (rec.realModified() &&
+                                    !Environment.Instance.allowUpdateInQueryMode(task.getCompIdx())) {
+                                    await dv.cancelEdit(EventsManager.REAL_ONLY, false);
+                                    task.WriteToMessagePanebyMsgId(MsgInterface.RT_STR_UPDATE_IN_QUERY);
+                                    await task.getForm().RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                                }
+                            }
+                        }
+                        if (!this.isForceExitPreRecordUpdate(task) &&
+                            (!task.isAborting() || MGDataCollection.Instance.GetTaskByID(task.getTaskTag()) != null)) {
+                            if ((!recModeIsDelete || task.getMode() === Constants.TASK_MODE_DELETE))
+                                await this.commitRecord(task, evt.reversibleExit());
+                        }
+                        if (!task.transactionFailed(ConstInterface.TRANS_RECORD_PREFIX) && !task.isAborting()) {
+                            if ((rec.getMode() === DataModificationTypes.Delete &&
+                                task.getMode() === Constants.TASK_MODE_DELETE) ||
+                                rec.getMode() !== DataModificationTypes.Delete)
+                                if (await task.evalEndCond(ConstInterface.END_COND_EVAL_AFTER))
+                                    await task.endTask(true, false, false);
+                        }
+                    }
+                    break;
+                case InternalInterface.MG_ACT_CTRL_PREFIX:
+                    if (rcBefore) {
+                        if (await ctrl.IsParkable() || ctrl === LastFocusedManager.getLastFocusedControl()) {
+                            ctrl.InControl = true;
+                            if (ctrl.ShouldRefreshOnControlEnter())
+                                await ctrl.getField().updateDisplay();
+                            task.setLastParkedCtrl(ctrl);
+                            RuntimeContextBase.Instance.CurrentClickedCtrl = null;
+                            await ctrl.SetFocus(ctrl, ctrl.getDisplayLine(false), true);
+                            this.setStopExecutionCtrl(null);
+                            MgControl.ReturnToCtrl = ctrl;
+                            task.InCtrlPrefix = false;
+                        }
+                        else {
+                            task.InCtrlPrefix = false;
+                            await this.HandleNonParkableControls(ctrl.getForm().getTask());
+                        }
+                    }
+                    break;
+                case InternalInterface.MG_ACT_CTRL_SUFFIX:
+                    if (!this.GetStopExecutionFlag()) {
+                        if (ctrl.isChoiceControl()) {
+                            ctrl.SetKeyboardLanguage();
+                        }
+                        if (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON)
+                            task.ActionManager.enable(InternalInterface.MG_ACT_BUTTON, false);
+                        if (task.getEnableZoomHandler() || ctrl.useZoomHandler())
+                            task.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, false);
+                        task.ActionManager.enable(InternalInterface.MG_ACT_RT_EDT_NULL, false);
+                    }
+                    if (rcBefore) {
+                        if (this.GetStopExecutionFlag()) {
+                            ctrl.InControl = true;
+                            return;
+                        }
+                        let fld = ctrl.getField();
+                        if (fld != null && (ctrl.Type === MgControlType.CTRL_TYPE_TEXT))
+                            await fld.updateDisplay();
+                        task.setLevel(Constants.TASK_LEVEL_RECORD);
+                        ctrl.setInControlSuffix(false);
+                        ctrl.IsInteractiveUpdate = false;
+                        if (ctrl.PropertyExists(PropInterface.PROP_TYPE_CUSTOM_VALIDATORS))
+                            await ctrl.getProp(PropInterface.PROP_TYPE_CUSTOM_VALIDATORS).RefreshDisplay(true);
+                        ctrl.ValidateControl = false;
+                        LastFocusedManager.setLastFocusedControl(task, null);
+                        if (await task.evalEndCond(ConstInterface.END_COND_EVAL_IMMIDIATE))
+                            await task.endTask(true, false, false);
+                    }
+                    break;
+                case InternalInterface.MG_ACT_TASK_PREFIX:
+                    task.setLevel(Constants.TASK_LEVEL_TASK);
+                    break;
+                case InternalInterface.MG_ACT_TASK_SUFFIX:
+                    task.setLevel(Constants.TASK_LEVEL_NONE);
+                    break;
+                case InternalInterface.MG_ACT_CYCLE_NEXT_REC:
+                    let form = task.getForm();
+                    if (!task.isMainProg() && form != null) {
+                        await form.moveInView(form.isLineMode()
+                            ? Constants.MOVE_UNIT_ROW
+                            : Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_NEXT);
+                        if (task.getExecEndTask())
+                            await task.endTask(true, false, false);
+                    }
+                    break;
+                case InternalInterface.MG_ACT_CYCLE_NEXT_DELETE_REC:
+                    if (task.DataView.isEmptyDataview())
+                        (task).setExecEndTask();
+                    else
+                        await this.HandleActionDelline(task, dv, rec, true);
+                    if (task.getExecEndTask())
+                        await task.endTask(true, false, false);
+                    break;
+                case InternalInterface.MG_ACT_SET_EXTERNAL_VALUE:
+                    let refreshDisplay = await evt.getArgList().getArgValue(1, StorageAttribute.BOOLEAN, 0) === '1' ? true : false;
+                    await ctrl.validateAndSetValueIfAllowed(evt.getValue(), refreshDisplay);
+                    break;
+            }
+        }
+    }
+    async handleNonReversibleEvent(task, eventCode) {
+        let rtEvt = new RunTimeEvent(task);
+        let exitCommand = (eventCode === InternalInterface.MG_ACT_EXIT || eventCode === InternalInterface.MG_ACT_CLOSE);
+        rtEvt.setInternal(eventCode);
+        if (exitCommand)
+            this._isNonReversibleExit = true;
+        try {
+            rtEvt.setNonReversibleExit();
+            rtEvt.setCtrl(task.getLastParkedCtrl());
+            rtEvt.setArgList(null);
+            await this.handleEvent(rtEvt, false);
+        }
+        finally {
+            if (exitCommand)
+                this._isNonReversibleExit = false;
+        }
+    }
+    async handleInternalEventWithTaskAndEventSubtype(task, eventCode, eventSubType) {
+        let lastParkedCtrl = task.getLastParkedCtrl();
+        let rtEvt;
+        if (eventCode < InternalInterface.MG_ACT_TOT_CNT && task != null && !(eventSubType === EventSubType.CancelIsQuit) && !task.ActionManager.isEnabled(eventCode))
+            return;
+        if (lastParkedCtrl !== null)
+            await this.handleInternalEventWithMgControl(lastParkedCtrl, eventCode, eventSubType);
+        else {
+            if (eventCode === InternalInterface.MG_ACT_RT_QUIT)
+                await this.handleInternalEventWithTaskAndEventSubtype(task, InternalInterface.MG_ACT_CANCEL, EventSubType.CancelIsQuit);
+            else {
+                rtEvt = new RunTimeEvent(task);
+                rtEvt.setInternal(eventCode);
+                rtEvt.SetEventSubType(eventSubType);
+                if (InternalInterface.BuiltinEvent(eventCode))
+                    await this.handleEvent(rtEvt, false);
+                else
+                    await this.commonHandler(rtEvt);
+            }
+        }
+    }
+    async handleInternalEventWithMgControl(ctrl, eventCode, eventSubType) {
+        let rtEvt;
+        if (eventCode === InternalInterface.MG_ACT_RT_QUIT)
+            await this.handleInternalEventWithMgControl(ctrl, InternalInterface.MG_ACT_CANCEL, EventSubType.CancelIsQuit);
+        else {
+            rtEvt = new RunTimeEvent(ctrl);
+            rtEvt.setInternal(eventCode);
+            rtEvt.SetEventSubType(eventSubType);
+            if (eventCode === InternalInterface.MG_ACT_RT_REFRESH_VIEW)
+                rtEvt.setIsRealRefresh(false);
+            if (InternalInterface.BuiltinEvent(eventCode))
+                await this.handleEvent(rtEvt, false);
+            else
+                await this.commonHandler(rtEvt);
+        }
+    }
+    getCurrField() {
+        return this._currField;
+    }
+    getCurrCtrl() {
+        return this._currCtrl;
+    }
+    getCurrTask() {
+        if (this._currField == null)
+            return null;
+        return this._currField.getTask();
+    }
+    setStopExecution(stop, clearEventsOnStopExecution) {
+        if (arguments.length === 1)
+            this.setStopExecution_0(stop);
+        else
+            this.setStopExecution_1(stop, clearEventsOnStopExecution);
+    }
+    setStopExecution_0(stop) {
+        this.setStopExecution(stop, ClearEventsOnStopExecution.ALL);
+    }
+    setStopExecution_1(stop, clearEventsOnStopExecution) {
+        if (stop)
+            if (clearEventsOnStopExecution == ClearEventsOnStopExecution.ALL)
+                this._eventsQueue.clear();
+            else if (clearEventsOnStopExecution == ClearEventsOnStopExecution.SERVER) {
+                let tmpVec = new List();
+                let rtEvt;
+                let i;
+                while (!this._eventsQueue.isEmpty()) {
+                    rtEvt = this._eventsQueue.poll();
+                    if (rtEvt.isFromServer()) {
+                        rtEvt.resetFromServer();
+                        tmpVec.push(rtEvt);
+                    }
+                }
+                for (i = 0; i < tmpVec.length; i++)
+                    this._eventsQueue.put(tmpVec.get_Item(i));
+            }
+        this._stopExecution = stop;
+    }
+    setStopExecutionCtrl(ctrl) {
+        if (this._stopExecutionCtrl === null || ctrl === null)
+            this._stopExecutionCtrl = ctrl;
+    }
+    async delCurrRec(task, inForceDel) {
+        let dv = task.DataView;
+        task.setMode(Constants.TASK_MODE_MODIFY);
+        await task.getForm().delCurrRec();
+        if (!task.DataView.isEmptyDataview()) {
+            if (dv.getCurrRecIdx() >= 0) {
+                if ((dv.getCurrRec()).getMode() !== DataModificationTypes.Delete && !inForceDel) {
+                    let ctrl = task.getLastParkedCtrl();
+                    await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+                    if (!this.GetStopExecutionFlag())
+                        if (ctrl === null)
+                            await this.HandleNonParkableControls(task);
+                        else
+                            await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_PREFIX);
+                }
+            }
+            else if (!task.getInCreateLine())
+                await this.handleNonReversibleEvent(task, InternalInterface.MG_ACT_EXIT);
+        }
+        else {
+            await this.HandleNonParkableControls(task);
+            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);
+        }
+    }
+    async updateConfirmed(task) {
+        let confirm;
+        let answer;
+        let ans;
+        if (task == null)
+            return false;
+        confirm = await task.checkProp(PropInterface.PROP_TYPE_CONFIRM_UPDATE, false);
+        if (!this._isInRecordFlushEvent && confirm && !task.DataSynced) {
+            ans = await GUIManager.Instance.confirm(MsgInterface.CRF_STR_CONF_UPD, Styles.MSGBOX_ICON_QUESTION | Styles.MSGBOX_BUTTON_YES_NO_CANCEL);
+            if (ans === Styles.MSGBOX_RESULT_YES)
+                answer = 'Y';
+            else if (ans === Styles.MSGBOX_RESULT_NO)
+                answer = 'N';
+            else
+                answer = 'C';
+        }
+        else
+            answer = 'Y';
+        switch (answer) {
+            case 'Y':
+                break;
+            case 'N':
+                await task.getForm().cancelEdit(false, false);
+                await task.getForm().RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                task.ConfirmUpdateNo = true;
+                return false;
+            case 'C':
+                this.setStopExecution(true);
+                this.setStopExecutionCtrl(LastFocusedManager.getLastFocusedControl());
+                await FocusManager.SetFocus(LastFocusedManager.getLastFocusedControl(), -1);
+                return false;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg('in ClientManager.Instance.updateConfirmed() illegal confirmation code: ' +
+                    confirm);
+                break;
+        }
+        return true;
+    }
+    setCompMainPrgTab(compMainPrgTable) {
+        this._compMainPrgTab = compMainPrgTable;
+    }
+    setEndOfWork(endOfWork_) {
+        this._endOfWork = endOfWork_;
+    }
+    getEndOfWork() {
+        return this._endOfWork;
+    }
+    getCompMainPrgTab() {
+        return this._compMainPrgTab;
+    }
+    inNonReversibleExit() {
+        return this._isNonReversibleExit;
+    }
+    pushRtEvent(rtEvt) {
+        this._rtEvents.push(rtEvt);
+    }
+    popRtEvent() {
+        if (this._rtEvents.count() === 0)
+            return null;
+        return this._rtEvents.pop();
+    }
+    storeLastSavedRouteEventOnLocalStorage() {
+        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_SRC_TSK, JSON.stringify(rtEvt.getTask().TaskDefinitionId));
+            if (rtEvt.getArgList().getSize() > 0) {
+                let str = new StringBuilder();
+                rtEvt.getArgList().buildXML(str);
+                dataStorage.setItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST, str.toString());
+            }
+        }
+    }
+    restoreLastSavedRouteEventFromLocalStorage() {
+        let dataStorage = window.localStorage;
+        let lastRouteEvent = dataStorage.getItem(ConstInterface.LAST_ROUTE_EVENT);
+        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();
+            taskDefinitionId.fromJSON(srcTaskDefinitionStr);
+            let srcTask = MGDataCollection.Instance.getCurrMGData().getTaskByTaskDefinitionID(taskDefinitionId);
+            let args = null;
+            if (routeArgListStr != null) {
+                args = new ArgumentsList();
+                args.fillList(routeArgListStr, srcTask);
+            }
+            EventsManager.Instance.AddLastSavedRouteEvent(srcTask, args);
+        }
+    }
+    getLastSavedRouteEvent() {
+        return this.lastSavedRouteEvent;
+    }
+    setLastSavedRouteEvent(rtEvt) {
+        if (rtEvt == null)
+            this.lastSavedRouteEvent = null;
+        else
+            this.lastSavedRouteEvent = rtEvt.replicate();
+    }
+    getLastRtEvent() {
+        if (this._rtEvents.count() === 0)
+            return null;
+        return this._rtEvents.peek();
+    }
+    setIgnoreUnknownAbort(val) {
+        this._ignoreUnknownAbort = val;
+    }
+    ignoreUnknownAbort() {
+        return this._ignoreUnknownAbort;
+    }
+    async failTaskOverlay(taskId, mgd) {
+        let cmd;
+        if (taskId !== null) {
+            this.setIgnoreUnknownAbort(true);
+            try {
+                cmd = CommandFactory.CreateNonReversibleExitCommand(taskId, false);
+                mgd.CmdsToServer.Add(cmd);
+                await RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+            }
+            finally {
+                this.setIgnoreUnknownAbort(false);
+            }
+        }
+    }
+    isEventScopeTrans() {
+        return this._eventScope === EventScope.TRANS;
+    }
+    setEventScopeTrans() {
+        this._eventScope = EventScope.TRANS;
+    }
+    clearEventScope() {
+        this._eventScope = EventScope.NONE;
+    }
+    GetEventTime() {
+        return this._eventsQueue.GetTime();
+    }
+    getMatchingAction(kbItm) {
+        let act = 0;
+        if (kbItm == null)
+            return act;
+        if (act === 0) {
+            if (kbItm.getAction() !== 0)
+                act = kbItm.getAction();
+            else if (kbItm.getKeyCode() === 45 && kbItm.getModifier() === Modifiers.MODIFIER_NONE && kbItm.getStates() === 0)
+                act = InternalInterface.MG_ACT_TOGGLE_INSERT;
+        }
+        return (act);
+    }
+    getExecStack() {
+        return this._execStack.peek();
+    }
+    pushExecStack(taskId, handlerId, operIdx) {
+        this._execStack.peek().push(MGDataCollection.Instance.getTaskIdById(taskId), handlerId, operIdx);
+    }
+    popExecStack() {
+        return this._execStack.peek().pop();
+    }
+    pushNewExecStacks() {
+        this._serverExecStack.push(null);
+        this._execStack.push(new ExecutionStack());
+    }
+    popNewExecStacks() {
+        this._serverExecStack.pop();
+        this._execStack.pop();
+    }
+    pushServerExecStack(taskId, handlerId, operIdx) {
+        if (this._serverExecStack.peek() === null) {
+            this._serverExecStack.pop();
+            this._serverExecStack.push(new ExecutionStack());
+        }
+        this._serverExecStack.peek().push(taskId, handlerId, operIdx);
+    }
+    clearServerExecStack() {
+        if (this._serverExecStack.peek() !== null) {
+            this._serverExecStack.peek().clear();
+        }
+    }
+    reverseServerExecStack() {
+        if (this._serverExecStack.peek() !== null)
+            this._serverExecStack.peek().reverse();
+    }
+    getNextOperIdx(oper, clearWhenFound) {
+        let tmpServerExecStackEntry = null;
+        let nextOperIdx = -1;
+        if (this._serverExecStack.count() !== 0 && this._serverExecStack.peek() !== null && !this._serverExecStack.peek().empty()) {
+            if (this._serverExecStack.peek().size() > this._execStack.peek().size()) {
+                let tmpServerExecStack = new ExecutionStack(this._serverExecStack.peek());
+                while (tmpServerExecStack.size() > this._execStack.peek().size()) {
+                    tmpServerExecStackEntry = tmpServerExecStack.pop();
+                }
+                if (this._execStack.peek().Equals(tmpServerExecStack) && tmpServerExecStackEntry.TaskId === oper.getTaskTag() && tmpServerExecStackEntry.HandlerId === oper.getHandlerId() && tmpServerExecStackEntry.OperIdx >= oper.getServerId()) {
+                    nextOperIdx = tmpServerExecStackEntry.OperIdx;
+                    if (clearWhenFound && this._serverExecStack.peek().size() === this._execStack.peek().size() + 1) {
+                        this._serverExecStack.peek().clear();
+                    }
+                }
+                else
+                    nextOperIdx = EventsManager.MAX_OPER;
+            }
+            else {
+                nextOperIdx = EventsManager.MAX_OPER;
+            }
+        }
+        return nextOperIdx;
+    }
+    setProcessingTopMostEndTask(inProcessingTopMostEndTask) {
+        this._processingTopMostEndTask = inProcessingTopMostEndTask;
+    }
+    getProcessingTopMostEndTask() {
+        return this._processingTopMostEndTask;
+    }
+    setAllowEvents(AllowEvents) {
+        this._allowEvents = AllowEvents;
+    }
+    setNonInteractiveAllowEvents(AllowEvents) {
+        if (AllowEvents)
+            this._allowEvents = EventsAllowedType.NON_INTERACTIVE;
+        else
+            this._allowEvents = EventsAllowedType.NONE;
+    }
+    getAllowEvents() {
+        return this._allowEvents;
+    }
+    NoEventsAllowed() {
+        return this._allowEvents === EventsAllowedType.NONE;
+    }
+    async handleCtrlModify(ctrl, act) {
+        if (ctrl == null || !ctrl.isModifiable())
+            return;
+        switch (act) {
+            case InternalInterface.MG_ACT_RT_EDT_NULL:
+            case InternalInterface.MG_ACT_CTRL_MODIFY:
+            case InternalInterface.MG_ACT_SELECTION:
+                break;
+            default:
+                return;
+        }
+        let rtEvt;
+        rtEvt = new RunTimeEvent(ctrl);
+        rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_MODIFY);
+        await this.handleEvent(rtEvt, false);
+    }
+    ActAllowed(act) {
+        let allowed = true;
+        switch (this.getAllowEvents()) {
+            case EventsAllowedType.ALL:
+                allowed = true;
+                break;
+            case EventsAllowedType.NONE:
+                allowed = (act === InternalInterface.MG_ACT_CRELINE);
+                break;
+            case EventsAllowedType.NON_INTERACTIVE:
+                switch (act) {
+                    case InternalInterface.MG_ACT_EXIT_SYSTEM:
+                    case InternalInterface.MG_ACT_EXIT:
+                    case InternalInterface.MG_ACT_CLOSE:
+                    case InternalInterface.MG_ACT_CRELINE:
+                    case InternalInterface.MG_ACT_CRELINE_ABOVE:
+                    case InternalInterface.MG_ACT_ROLLBACK:
+                        allowed = true;
+                        break;
+                    default:
+                        allowed = false;
+                        break;
+                }
+                break;
+        }
+        return allowed;
+    }
+    async commitRecord(task, isReversibleExit) {
+        let dv = task.DataView;
+        let rec = dv.getCurrRec();
+        let forceSuffix = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);
+        let isSelectionTable = await task.checkProp(PropInterface.PROP_TYPE_SELECTION, false);
+        let isNewRec = rec.isNewRec();
+        let savePrevCurrRec = true;
+        let recModified = rec.Modified;
+        if (!dv.recInModifiedTab(rec.getId()))
+            rec.clearFlagsHistory();
+        await task.TaskTransactionManager.checkAndCommit(isReversibleExit, ConstInterface.TRANS_RECORD_PREFIX, task.ConfirmUpdateNo);
+        if (task.transactionFailed(ConstInterface.TRANS_RECORD_PREFIX)) {
+            try {
+                task.DataSynced = true;
+                this.setStopExecution(false);
+                await task.handleEventOnSlaveTasks(InternalInterface.MG_ACT_REC_PREFIX);
+            }
+            finally {
+                this.setStopExecution(true);
+            }
+        }
+        else if (task.isAborting())
+            this.setStopExecution(true);
+        else {
+            if (recModified)
+                rec.setLateCompute(true);
+            if (!this._stopExecution)
+                task.setLevel(Constants.TASK_LEVEL_TASK);
+            rec.resetUpdated();
+            rec.resetModified();
+            if (!recModified && !forceSuffix && (!isSelectionTable || !task.InSelect)) {
+                if (isNewRec) {
+                    dv.setPrevCurrRec();
+                    savePrevCurrRec = false;
+                    rec.setNewRec();
+                    await task.getForm().cancelEdit(false, false);
+                    await this.HandleStopRowEditing(task);
+                }
+                else if (!rec.getForceSaveOrg())
+                    await dv.cancelEdit(EventsManager.REAL_ONLY, true);
+                else
+                    dv.saveOriginal();
+            }
+            else
+                dv.saveOriginal();
+        }
+        if (savePrevCurrRec)
+            dv.setPrevCurrRec();
+    }
+    incLocateTimerCB(taskObj) {
+        let task = taskObj;
+        let rtEvt = new RunTimeEvent(task, true);
+        rtEvt.setInternal(InternalInterface.MG_ACT_INCREMENTAL_LOCATE);
+        rtEvt.setMainPrgCreator(task);
+        rtEvt.setCtrl(task.getLastParkedCtrl());
+        this.addToTail(rtEvt);
+    }
+    static async doSyncForSubformParent(task) {
+        let parentTask = task.getParent();
+        let parentDv = parentTask.DataView;
+        let parentRec = parentDv.getCurrRec();
+        if (task.IsSubForm && parentRec != null && parentRec.Modified && !parentDv.isEmptyDataview()) {
+            parentRec.setMode(DataModificationTypes.Update);
+            await parentDv.addCurrToModified(false);
+            ((parentDv.getCurrRec())).Synced = true;
+            parentDv.setChanged(true);
+            let dataViewExecuteLocalUpdatesCommand = CommandFactory.CreateDataViewCommand(parentTask.getTaskTag(), DataViewCommandType.ExecuteLocalUpdates);
+            await parentTask.DataviewManager.Execute(dataViewExecuteLocalUpdatesCommand);
+        }
+    }
+    async ProcessAbortingError(ex) {
+        let eMsg;
+        let errForConsole;
+        let errForMsgBox;
+        if (ex instanceof ServerError)
+            eMsg = ex.GetMessage();
+        else
+            eMsg = ((ex.Message !== null) ? ex.Message : ex.GetType());
+        errForConsole = StrUtil.getConsoleErorString(eMsg);
+        errForMsgBox = StrUtil.getMsgBoxErorString(eMsg);
+        if (ex.InnerException !== null)
+            Logger.Instance.WriteExceptionToLog(ex.InnerException, errForConsole);
+        else {
+            if (!(ex instanceof ServerError) || Logger.Instance.LogLevel !== Logger_LogLevels.Basic) {
+                Logger.Instance.WriteExceptionToLogWithMsg(errForConsole);
+            }
+        }
+        let sendUnloadToServer = RuntimeContextBase.Instance.ContextID !== RuntimeContextBase.noContextId;
+        MGDataCollection.Instance.currMgdID = 0;
+        let messageString = LanguageData.Instance.getConstMessage(MsgInterface.BRKTAB_STR_ERROR);
+        let style = 16;
+        if (ex.Message.startsWith('<HTML')) {
+            this.processHTMLContent(ex.Message);
+        }
+        else {
+            if (this.ShowErrorInMessageBox(ex)) {
+                await GUIManager.Instance.MessageBox(messageString, errForMsgBox, style);
+            }
+            if (ex instanceof ServerError) {
+                if (ex.GetCode() == ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED ||
+                    ex.GetCode() == ServerError.ERR_EXECUTED_PROGRAM_CHANGED) {
+                    Commands.addGlobalCommand(CommandType.RELOAD_PAGE);
+                    Commands.beginInvoke();
+                }
+            }
+        }
+        if (ex instanceof ServerError) {
+            if (ex.GetCode() === ServerError.ERR_CTX_NOT_FOUND ||
+                ex.GetCode() === ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED ||
+                ex.GetCode() === ServerError.ERR_EXECUTED_PROGRAM_CHANGED) {
+                sendUnloadToServer = false;
+            }
+        }
+        if (sendUnloadToServer) {
+            try {
+                let cmd = CommandFactory.CreateUnloadCommand();
+                MGDataCollection.Instance.getMGData(0).CmdsToServer.Add(cmd);
+                await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+            }
+            catch (ex3) {
+                if (ex3 instanceof ApplicationException) {
+                    Logger.Instance.WriteExceptionToLog(ex3);
+                }
+                else
+                    throw ex3;
+            }
+        }
+        GUIManager.Instance.abort();
+    }
+    processHTMLContent(htmlContent) {
+        Commands.addShowHTMLError(CommandType.SHOW_HTML_ERROR, htmlContent);
+        Commands.beginInvoke();
+    }
+    ShowErrorInMessageBox(ex) {
+        if (!(ex instanceof ServerError))
+            return true;
+        if ((ex.GetCode() == ServerError.ERR_EXECUTED_PROGRAM_CHANGED ||
+            ex.GetCode() == ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED) &&
+            RuntimeContextBase.Instance.ContextID === RuntimeContextBase.noContextId)
+            return false;
+        return true;
+    }
+    getIsInViewRefresh() {
+        return this.isInViewRefresh;
+    }
+    setIsInViewRefresh(inViewRefresh) {
+        this.isInViewRefresh = inViewRefresh;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventsManager.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/event/EventsManager.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Constants,\r\n  ForceExit,\r\n  InternalInterface,\r\n  Logger,\r\n  Logger_LogLevels,\r\n  MgControlType,\r\n  Misc,\r\n  MsgInterface,\r\n  Priority,\r\n  RaiseAt,\r\n  StorageAttribute,\r\n  StrUtil,\r\n  SubformType\r\n} from '@magic-xpa/utils';\r\nimport {ApplicationException, Int32, List, NString, RefParam, Stack, StringBuilder, Thread, isNullOrUndefined} from '@magic-xpa/mscorelib';\r\nimport {\r\n  Commands,\r\n  CommandType,\r\n  DataModificationTypes,\r\n  ExpVal,\r\n  FocusManager,\r\n  GuiConstants,\r\n  GuiEnvironment,\r\n  ITask,\r\n  KeyboardItem,\r\n  LastFocusedVal,\r\n  Manager,\r\n  MgControlBase,\r\n  MgFormBase,\r\n  Modifiers,\r\n  PropInterface,\r\n  RuntimeContextBase,\r\n  Styles,\r\n  TaskDefinitionId\r\n} from '@magic-xpa/gui';\r\nimport {EventSubType} from '../enums';\r\nimport {RollbackEventCommand_RollbackType} from '../commands/ClientToServer/RollbackEventCommand';\r\nimport {MgControl} from '../gui/MgControl';\r\nimport {MgPriorityBlockingQueue} from '../util/MgPriorityBlockingQueue';\r\nimport {CompMainPrgTable} from '../rt/CompMainPrgTable';\r\nimport {Field} from '../data/Field';\r\nimport {RunTimeEvent} from './RunTimeEvent';\r\nimport {MgForm} from '../gui/MgForm';\r\nimport {EventHandler, RetVals} from './EventHandler';\r\nimport {FlowMonitorQueue} from '../util/FlowMonitorQueue';\r\nimport {GUIManager} from '../GUIManager';\r\nimport {Task} from '../tasks/Task';\r\nimport {Task_SubformExecModeEnum, TaskBase} from '../tasks/TaskBase';\r\nimport {ArgumentsList} from '../rt/ArgumentsList';\r\nimport {MGData} from '../tasks/MGData';\r\nimport {HandlersTable} from '../rt/HandlersTable';\r\nimport {MGDataCollection} from '../tasks/MGDataCollection';\r\nimport {RecordOutOfDataViewException} from '../data/RecordOutOfDataViewException';\r\nimport {CommandsProcessorBase, CommandsProcessorBase_SendingInstruction} from '../CommandsProcessorBase';\r\nimport {CommandsTable} from '../CommandsTable';\r\nimport {CommandFactory} from '../commands/ClientToServer/CommandFactory';\r\nimport {IClientCommand} from '../commands/IClientCommand';\r\nimport {CommandsProcessorManager} from '../CommandsProcessorManager';\r\nimport {Operation} from '../rt/Operation';\r\nimport {ClientRefreshCommand} from '../commands/ServerToClient/ClientRefreshCommand';\r\nimport {RemoteCommandsProcessor} from '../remote/RemoteCommandsProcessor';\r\nimport {ExecutionStack} from '../rt/ExecutionStack';\r\nimport {ExecutionStackEntry} from '../rt/ExecutionStackEntry';\r\nimport {EventHandlerPosition} from './EventHandlerPosition';\r\nimport {DataView} from '../data/DataView';\r\nimport {Event} from './Event';\r\nimport {Record} from '../data/Record';\r\nimport {ConstInterface} from '../ConstInterface';\r\nimport {FlowMonitorInterface} from '../FlowMonitorInterface';\r\nimport {DataViewCommandType} from '../commands/ClientToServer/DataviewCommand';\r\nimport {ServerError} from '../remote/ServerError';\r\nimport {Environment} from '../env/Environment';\r\nimport {LastFocusedManager} from '../rt/LastFocusedManager';\r\nimport {EventsAllowedType, IEventsManager} from './IEventsManager';\r\nimport {LanguageData} from '../env/LanguageData';\r\nimport {Subject} from 'rxjs';\r\nimport {ClientManager} from '../ClientManager';\r\nimport {ContextTerminationEventCommand} from '../commands/ClientToServer/ContextTerminationEventCommand';\r\nimport { ClearEventsOnStopExecution } from '../AccessHelper';\r\n\r\n\r\nenum EventScope {\r\n  NONE = ' ',\r\n  TRANS = 'T'\r\n}\r\n\r\n/// <summary>\r\n///   this class manage the events, put them in a queue and handle them\r\n/// </summary>\r\nexport class EventsManager implements IEventsManager {\r\n  // LOCAL CONSTANTS\r\n  private static REAL_ONLY: boolean = true;\r\n  private static MAX_OPER: number = 9999;\r\n  private static userGrantedForContextActivity = true;\r\n  private _eventsQueue: MgPriorityBlockingQueue = null; // the queue of events to execute\r\n  private _execStack: Stack<ExecutionStack> = null; // Execution stack of raise event operation or calls to user\r\n  private _rtEvents: Stack<RunTimeEvent> = null; // A stack of in-process run-time events (the last one is at the top).\r\n  private _serverExecStack: Stack<ExecutionStack> = null; // Execution stack of Execution stacks of operations that\r\n  private _allowEvents: EventsAllowedType = EventsAllowedType.ALL;\r\n  private _compMainPrgTab: CompMainPrgTable = null; // the order of handling main programs of components\r\n  private _currCtrl: MgControl = null;\r\n  private _currField: Field = null; // for every event executed this variable will contain the field attached to the control on which the event was fired\r\n  private _currKbdItem: KeyboardItem = null;\r\n  private _endOfWork: boolean = false;\r\n  private _eventScope: EventScope = EventScope.NONE; // instructs how to process events which are propagated to slave tasks during execution.\r\n  private _forceExit: ForceExit = ForceExit.None;\r\n  private _forceExitTask: Task = null;\r\n  private _ignoreUnknownAbort: boolean = false; // TRUE when 'abort' commands on unknown tasks may arrive\r\n  private _initialized: boolean = false; // used to detect re-initialization\r\n  private _isHandlingForceExit: boolean = false; // indicate we are currently handling a forceExit related handler\r\n  private _isNonReversibleExit: boolean = false; // is the command nonreversible\r\n  private _isInRecordFlushEvent: boolean = false; // true if current act is MG_ACT_RT_REFRESH_RECORD\r\n\r\n  private static clientInactivityTimerON = false;\r\n  private static clientContextInactivityTimerAborted = false;\r\n  private lastSavedRouteEvent: RunTimeEvent = null;\r\n  // was sent from the server. we need a stack of execstacks\r\n  // here because we might call a new program before we handled\r\n  // the previous server exec stack\r\n  private _stopExecution: boolean = false;\r\n  private _processingTopMostEndTask: boolean = false; // indication whether we are currently processing events from the\r\n  private _stopExecutionCtrl: MgControl = null; // holds the ctrl on which we get the first stop execution\r\n\r\n  public guiPendingEvent: any = null;\r\n  // KEYBOARD EVENTS CONSTANTS\r\n  readonly KBI_DOWN: KeyboardItem = null;\r\n  readonly KBI_UP: KeyboardItem = null;\r\n\r\n  // CONTEXT TERMINATION WARNING CONSTANTS\r\n  readonly confirmationDialogMsg: string = 'The server context serving this application is about to time out. Do you want to continue your work?';\r\n  readonly confirmationDialogTitle: string = 'Session is about to be terminated!';\r\n\r\n  static Instance: EventsManager = new EventsManager();\r\n\r\n  private _lastFailedFocusedControl: MgControlBase = null;\r\n\r\n  private isSpinnerShown: boolean = false;\r\n  private isInViewRefresh: boolean = false;\r\n\r\n  SpinnerStopped: Subject<number> = new Subject();\r\n\r\n  static clientBusyTimeStart = 0;\r\n  /// <summary>\r\n  ///   private CTOR to prevent instantiation\r\n  /// </summary>\r\n  private constructor() {\r\n    this._rtEvents = new Stack();\r\n\r\n    this._eventsQueue = new MgPriorityBlockingQueue();\r\n\r\n    this._execStack = new Stack();\r\n    this._execStack.push(new ExecutionStack());\r\n\r\n    this._serverExecStack = new Stack();\r\n    this._serverExecStack.push(null);\r\n\r\n\r\n    this.KBI_DOWN = new KeyboardItem(GuiConstants.KEY_DOWN, Modifiers.MODIFIER_NONE);\r\n    this.KBI_UP = new KeyboardItem(GuiConstants.KEY_UP, Modifiers.MODIFIER_NONE);\r\n\r\n  }\r\n\r\n  getPendingGuiEvent(): any {\r\n    return this.guiPendingEvent;\r\n  }\r\n\r\n  setPendingGuiEvent(guiEvent: any): void {\r\n    this.guiPendingEvent = guiEvent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add an event to the end of the queue\r\n  /// </summary>\r\n  /// <param name = \"irtEvt\">the event to be added </param>\r\n  addToTail(rtEvt: RunTimeEvent): void {\r\n    // if current event is not idle time event check if there is clientInactivityTimer running?\r\n    // if so , stop this client Context inactivity timer\r\n    if (!rtEvt.isIdleTimer()) {\r\n      if (EventsManager.clientInactivityTimerON) {\r\n        EventsManager.clientContextInactivityTimerAborted = true;\r\n      }\r\n    } else {\r\n\r\n      // if client is idle after recreating context , then add last saved route event\r\n      if (this.getLastSavedRouteEvent() != null) {\r\n        this.addToTail(this.getLastSavedRouteEvent());\r\n        this.setLastSavedRouteEvent(null);\r\n      }\r\n    }\r\n\r\n    this._eventsQueue.put(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add an keyboard event to the end of the queue\r\n  /// </summary>\r\n  /// <param name = \"mgForm\">form </param>\r\n  /// <param name = \"mgControl\">control </param>\r\n  /// <param name = \"modifier\">modifier </param>\r\n  /// <param name = \"start\">start of selected text </param>\r\n  /// <param name = \"end\">end of selected text  </param>\r\n  /// <param name = \"text\">text </param>\r\n  /// <param name = \"im\">im </param>\r\n  /// <param name = \"isActChar\">is keyboard char </param>\r\n  /// <param name = \"suggestedValue\">suggested value for choice </param>\r\n  /// <param name = \"code\">code to be added in the queue </param>\r\n  AddKeyboardEvent(mgForm: MgFormBase, mgControl: MgControlBase, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, code: number): void {\r\n    let rtEvt: RunTimeEvent = (mgControl !== null) ? new RunTimeEvent(<MgControl>mgControl, true, false) : new RunTimeEvent(<Task>mgForm.getTask(), true);\r\n\r\n    rtEvt.setInternal(code);\r\n\r\n    let newKbItem: KeyboardItem = new KeyboardItem(keyCode, modifier);\r\n\r\n    if (isActChar && (mgControl !== null && (mgControl.isTextControl())))\r\n      newKbItem.setAction(InternalInterface.MG_ACT_CHAR);\r\n\r\n    rtEvt.setKeyboardItem(newKbItem);\r\n\r\n    if (code === InternalInterface.MG_ACT_CTRL_KEYDOWN) {\r\n      rtEvt.setEditParms(start, end, text);\r\n    } else\r\n      rtEvt.setValue(suggestedValue);\r\n\r\n    this.addToTail(rtEvt);\r\n    return;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   QCR 760381 if after handling the event the current control is unparkable try\r\n  ///   an move to the next parkable control\r\n  /// </summary>\r\n  async checkParkability(): Promise<void> {\r\n    let current: MgControl = LastFocusedManager.getLastFocusedControl();\r\n\r\n    /* QCR# 925464. The problem was that on deleting a record, CS of the control gets executed.\r\n     * So, the task's level is set to TASK. Then we go to server an on returning back from the server,\r\n     * we refresh the form. Here, since the last parked control i.e. \"from\" (numeric) is hidden,\r\n     * we try to park on the next parkable control from Property.RefreshDisplay(). This makes the\r\n     * task's level as CONTROL. Now, we try to execute RP, but since the level is CONTROL,\r\n     * we do not execute it. The solution is that checkParkability() which is called from\r\n     * Property.RefreshDisplay(), should try to park on the control only if the task's level is CONTROL.\r\n     */\r\n    if (current !== null && (current.getForm().getTask()).getLevel() === Constants.TASK_LEVEL_CONTROL && !await current.IsParkable())\r\n      await this.HandleNonParkableControls(current.getForm().getTask());\r\n  }\r\n\r\n  async HandleParkabilityOnRowChange(itask: ITask): Promise<void> {\r\n    await this.HandleNonParkableControls(itask);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   handle situation with no parkable controls\r\n  /// </summary>\r\n  /// <param name = \"itask\"></param>\r\n  async HandleNonParkableControls(itask: ITask): Promise<void> {\r\n    let task: Task = <Task>itask;\r\n    // we can not stay in create mode with no parkable controls\r\n    if (task.getMode() === Constants.TASK_MODE_CREATE && task.IsInteractive) {\r\n      await task.enableModes();\r\n      let oldMode: string = task.getOriginalTaskMode();\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n      if (!this.GetStopExecutionFlag()) {\r\n        if (oldMode !== Constants.TASK_MODE_CREATE) {\r\n          task.setMode(oldMode);\r\n          await (<DataView>task.DataView).currRecCompute(true);\r\n          await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n          await (<MgForm>task.getForm()).RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n          task.setLastParkedCtrl(null);\r\n          await FocusManager.SetFocus(task, null, -1, true);\r\n          return;\r\n        }\r\n      }\r\n      // we can not stay in create mode or in stop execution state with no parkable controls\r\n      // Do not give park error, if task is opened in create mode. This is temporary change for customer problem.\r\n      //this.exitWithError(task, MsgInterface.RT_STR_CRSR_CANT_PARK);\r\n    }\r\n\r\n    // While handle non-parkability condition, ensure CS is called for control if it is in Control level then parking is set on form.\r\n    if (task.getLevel() === Constants.TASK_LEVEL_CONTROL)\r\n      await this.handleInternalEventWithMgControlBase(task.getLastParkedCtrl(), InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n\r\n    task.setLastParkedCtrl(null);\r\n    MgControl.ReturnToCtrl = null;\r\n    await FocusManager.SetFocus(task, null, -1, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   handle a single event\r\n  /// </summary>\r\n  /// <param name = \"irtEvt\">the event to process </param>\r\n  /// <param name = \"returnedFromServer\">indicates whether we returned from the server - to be passed to handler.execute() </param>\r\n  async handleEvent(rtEvt: RunTimeEvent, returnedFromServer: boolean): Promise<void> {\r\n    let handler: EventHandler = null;\r\n    let pos: EventHandlerPosition = new EventHandlerPosition();\r\n    let task: Task = <Task>rtEvt.getTask();\r\n    let ctrl: MgControl = <MgControl>task.getLastParkedCtrl();\r\n    let forceExitDone: boolean = false;\r\n    let endTaskError: boolean = false;\r\n    let oldRtEvt: RunTimeEvent = null;\r\n    let oldForceExit: ForceExit = this.getForceExit();\r\n    let oldForceExitTask: Task = this.getForceExitTask();\r\n    let oldIsHandlingForceExit: boolean = this._isHandlingForceExit;\r\n    let restoreIsForceExit: boolean = false;\r\n    let restoreCurrCtrl: MgControl;\r\n    let restoreCurrField: Field = null;\r\n\r\n    // the action need to be check according to the task on the event.\r\n    // If the action is internal (under ACT_TOT), do nothing if its disabled or not allowed.\r\n    if ((rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL)) {\r\n      // do nothing if action is 1. not enabled 2. wait == no and events are not allowed\r\n      if (rtEvt.InternalEvent < InternalInterface.MG_ACT_TOT_CNT && (!task.ActionManager.isEnabled(rtEvt.InternalEvent) || (!rtEvt.isImmediate() && this.NoEventsAllowed())))\r\n        return;\r\n    } else\r\n    // do the handlers when 1. wait == yes or 2. events are allowed\r\n    if (!rtEvt.isImmediate() && this.NoEventsAllowed())\r\n      return;\r\n\r\n    restoreCurrCtrl = this._currCtrl;\r\n    this._currCtrl = ctrl; // save current control for HANDLER_CTRL function\r\n\r\n    let propagate: boolean = rtEvt.getType() !== ConstInterface.EVENT_TYPE_INTERNAL || rtEvt.getInternalCode() < 1000;\r\n\r\n    try {\r\n\r\n      this.pushRtEvent(rtEvt);\r\n\r\n      await this.CheckAndShowSpinner(true);\r\n\r\n      // do some common processing and if the result is true then continue\r\n      // with the user defined handlers\r\n      let bRcBefore: boolean = await this.commonHandlerBefore(rtEvt);\r\n\r\n      restoreCurrField = this._currField;\r\n      this._currField = <Field>task.getCurrField();\r\n\r\n      if (bRcBefore) {\r\n        pos.init(rtEvt);\r\n        // get the first handler for the current event\r\n        handler = pos.getNext();\r\n\r\n        if (handler !== null && handler.getEvent() !== null && handler.getEvent().UserEvt !== null)\r\n          this.setForceExit(handler.getEvent().UserEvt.ForceExit, task);\r\n\r\n        // execute the chain of handlers for the current event. the execution\r\n        // continues till an event handler returns false.\r\n        while (handler !== null) {\r\n          let handlerContextTask: Task = null;\r\n          let rtEvtChanged: boolean;\r\n          try {\r\n            let enabledCndCheckedAndTrue: boolean = false;\r\n\r\n            // if there is a handler change the handler's context task to the event's task\r\n            handlerContextTask = <Task>handler.getTask().GetContextTask();\r\n            if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() >= 1000 && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_VARIABLE)\r\n              handler.getTask().SetContextTask(handler.getTask());\r\n            else\r\n              handler.getTask().SetContextTask(rtEvt.getTask());\r\n\r\n            // there is no need to handle ForceExit for non-user events\r\n            if (handler.getEvent().getType() === ConstInterface.EVENT_TYPE_USER && await handler.isEnabled()) {\r\n              enabledCndCheckedAndTrue = true;\r\n              this._isHandlingForceExit = false;\r\n              restoreIsForceExit = true;\r\n              // handle forceExit only once\r\n              if (await this.handleForceExitBefore(handler.getEvent(), rtEvt)) {\r\n                forceExitDone = true;\r\n              }\r\n            }\r\n\r\n            // check if the current run time event is different from the event\r\n            // of the handler\r\n            if (rtEvt !== handler.getEvent()) {\r\n              // the new runtime event is that of the handler combined with the\r\n              // data of the current runtime event.\r\n              // the purpose of this is to propagate the event of the handler\r\n              // in place of the original event\r\n              oldRtEvt = rtEvt;\r\n              rtEvt = new RunTimeEvent(handler.getEvent(), rtEvt);\r\n              rtEvtChanged = true;\r\n\r\n              // there is a new runtime event to handle so pop the old one and push\r\n              // the new one instead.\r\n              this.popRtEvent();\r\n              this.pushRtEvent(rtEvt);\r\n            } else\r\n              rtEvtChanged = false;\r\n\r\n            if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_REC_SUFFIX)\r\n              rtEvt.getTask().setInRecordSuffix(true);\r\n\r\n            this.createEventArguments(rtEvt);\r\n            let handlerRetVals: RetVals = await handler.execute(rtEvt, returnedFromServer, enabledCndCheckedAndTrue);\r\n            if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_REC_SUFFIX)\r\n              rtEvt.getTask().setInRecordSuffix(false);\r\n            propagate = handlerRetVals.Propagate;\r\n            if (!handlerRetVals.Enabled && rtEvtChanged) {\r\n              rtEvt = oldRtEvt;\r\n              oldRtEvt = null;\r\n              rtEvtChanged = false;\r\n              // there is a new runtime event to handle so pop the old one and push\r\n              // the new one instead.\r\n              this.popRtEvent();\r\n              this.pushRtEvent(rtEvt);\r\n            }\r\n\r\n            // check if we have fulfilled the end condition\r\n            // After executing a handler, before ending a task (if the end condition is TRUE),\r\n            // we should check if the task is not already closed. This can happen like in case\r\n            // of QCR #796476 --- a non-interactive task has called an interactive task from\r\n            // task suffix. Now if we press Alt+F4, we get EXIT_SYSTEM act. And so we close\r\n            // all tasks starting from Main Program. So, when we come out of the TS handler\r\n            // execution, the task is already closed.\r\n            // For Offline : TP is executed at client side. If we are in Task Prefix, dont check endTask condition here.\r\n            if (rtEvt.getInternalCode() !== InternalInterface.MG_ACT_TASK_PREFIX && task.isStarted() && task.getExecEndTask()) {\r\n              endTaskError = await task.endTask(true, false, false);\r\n              if (endTaskError)\r\n                break;\r\n            }\r\n\r\n            if (this.GetStopExecutionFlag()) {\r\n              if (await this.handleStopExecution(rtEvt))\r\n                break;\r\n            }\r\n          } finally {\r\n            // restoring the context\r\n            handler.getTask().SetContextTask(handlerContextTask);\r\n          }\r\n\r\n          if (!propagate)\r\n            break;\r\n\r\n          if (rtEvtChanged)\r\n            handler = pos.getNext(rtEvt);\r\n          // get the next handler for the current event\r\n          else\r\n            handler = pos.getNext();\r\n          if (handler !== null)\r\n            FlowMonitorQueue.Instance.addTaskEvent(rtEvt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_PROPAGATE, task.GetTaskDetails());\r\n        }\r\n        if (propagate && !endTaskError)\r\n          await this.commonHandler(rtEvt);\r\n      }\r\n      if (!endTaskError) {\r\n        await this.commonHandlerAfter(rtEvt, bRcBefore);\r\n      }\r\n      if (forceExitDone && this._isHandlingForceExit) {\r\n        this._isHandlingForceExit = false;\r\n        await this.handleForceExitAfter(rtEvt);\r\n      }\r\n      this.setForceExit(oldForceExit, oldForceExitTask);\r\n      if (restoreIsForceExit)\r\n        this._isHandlingForceExit = oldIsHandlingForceExit;\r\n    } finally {\r\n      this._currCtrl = restoreCurrCtrl;\r\n      this._currField = restoreCurrField;\r\n      this.popRtEvent();\r\n\r\n    }\r\n\r\n    // update the display\r\n    GUIManager.Instance.execGuiCommandQueue();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   This method simulates all events that are in selection sequence starting from focus event\r\n  ///   It is used in :\r\n  ///   actions CTRL+TAB && CTRL+SHIFT+TAB that move us to the next/previous item in Tab control\r\n  ///   click or accelerator on push button\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <param name = \"val\"></param>\r\n  /// <param name = \"line\">ctrl line</param>\r\n  /// <param name = \"produceClick\">true should produce click event</param>\r\n  private async simulateSelection(ctrl: MgControlBase, val: any, line: number, produceClick: boolean): Promise<void> {\r\n    let mgControl: MgControl = <MgControl>ctrl;\r\n    let currTask: Task = <Task>mgControl.getForm().getTask();\r\n    let cancelWasRaised: boolean = currTask.cancelWasRaised();\r\n\r\n    // if (mgControl.Type === MgControlType.CTRL_TYPE_TAB) {\r\n    //   if (!mgControl.isModifiable() || !mgControl.IsParkable()) {\r\n    //     mgControl.restoreOldValue();\r\n    //     let lastFocusedControl: MgControl = GUIManager.getLastFocusedControl();\r\n    //     if (lastFocusedControl !== null)\r\n    //       Manager.SetFocus(lastFocusedControl, -1);\r\n    //     return;\r\n    //   }\r\n    // }\r\n\r\n    // when a push button is about to raise a 'Cancel' or a 'Quit' event. we do not want to set the new value to the field.\r\n    // That setting might cause a rec suffix and a variable change.\r\n    if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON) {\r\n      let aRtEvt: RunTimeEvent = new RunTimeEvent(mgControl);\r\n      let raiseAt: RaiseAt = <RaiseAt>(await (mgControl.getProp(PropInterface.PROP_TYPE_RAISE_AT)).getValueInt());\r\n      if (aRtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && (aRtEvt.InternalEvent === InternalInterface.MG_ACT_CANCEL || aRtEvt.InternalEvent === InternalInterface.MG_ACT_RT_QUIT)) {\r\n        if (raiseAt === RaiseAt.TaskInFocus)\r\n          currTask = LastFocusedManager.Instance.getLastFocusedTask();\r\n        cancelWasRaised = currTask.cancelWasRaised();\r\n        currTask.setCancelWasRaised(true);\r\n      }\r\n\r\n      if (raiseAt === RaiseAt.TaskInFocus)\r\n        mgControl.setRtEvtTask(LastFocusedManager.Instance.getLastFocusedTask());\r\n    }\r\n\r\n    // first we handle focus\r\n    await this.handleFocus(mgControl, line, produceClick);\r\n\r\n    currTask.setCancelWasRaised(cancelWasRaised);\r\n\r\n    if (this._stopExecution)\r\n      return;\r\n\r\n    // QCR# 974047 : If we have a Push Button with Allow Parking = No and field is attached to it, don't handle the event.\r\n    // This is same as online. In online, if field is not attached to non parkable push Button, we handle the event\r\n    // But if field is attached to it, we don't handle event.\r\n    // So if control is push button, execute handleEvent only when field is not attached or ParkonCLick is No or\r\n    // ParkonCLick and allowparking is both Yes\r\n    let controlIsParkable: boolean = await mgControl.IsParkable();\r\n    if (mgControl.Type !== MgControlType.CTRL_TYPE_BUTTON || (mgControl.getField() === null || controlIsParkable)) {\r\n\r\n      // QCR #301652. For non-parkable button control with event raised at the container task will be changed so\r\n      // when the button is clicked then the task will get focus. (as in Online and as if the button was parkable).\r\n      // The focus will be on the first control.\r\n      if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON && !controlIsParkable) {\r\n        let subformTask: Task = <Task>mgControl.getForm().getTask();\r\n        if (subformTask.IsSubForm) {\r\n          currTask = LastFocusedManager.Instance.getLastFocusedTask();\r\n          // Defect 115474. For the same task do not move to the first control.\r\n          if (subformTask !== currTask && subformTask.pathContains(currTask)) {\r\n\r\n            if (subformTask.getLevel() === Constants.TASK_LEVEL_TASK) { // TODO: Check if this code can be moved to HandleNonParkableControls()\r\n              await this.handleInternalEventWithTask(subformTask, InternalInterface.MG_ACT_REC_PREFIX);\r\n            }\r\n            await this.HandleNonParkableControls(subformTask);\r\n          }\r\n        }\r\n      }\r\n\r\n\r\n      // then ACT_HIT is sent\r\n      let rtEvt: RunTimeEvent = new RunTimeEvent(mgControl);\r\n      RuntimeContextBase.Instance.CurrentClickedCtrl = mgControl;\r\n      rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_HIT);\r\n      await this.handleEvent(rtEvt, false);\r\n      if (this._stopExecution)\r\n        return;\r\n    }\r\n\r\n    // and selection is handled in the end if previous actions succeeded\r\n    if (mgControl.Type !== MgControlType.CTRL_TYPE_BUTTON)\r\n    // for button\\check we do not call this to prevent recursion\r\n      await this.handleSelection(mgControl, line, val);\r\n\r\n    if (this._stopExecution)\r\n      return;\r\n    // then mouse up\r\n    await this.handleMouseUp(mgControl, line, produceClick);\r\n  }\r\n\r\n  /// <summary> activate handleInternalEvent with isQuit = false</summary>\r\n  /// <param name=\"itask\">a reference to the task</param>\r\n  /// <param name=\"eventCode\">the code of the event</param>\r\n  async handleInternalEventWithTask(itask: ITask, eventCode: number): Promise<void> {\r\n    await this.handleInternalEventWithTaskAndSubformRefresh(itask, eventCode, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   activate handleInternalEvent with isQuit = false\r\n  /// </summary>\r\n  /// <param name = \"itask\">a reference to the task </param>\r\n  /// <param name = \"eventCode\">the code of the event </param>\r\n  /// <param name=\"subformRefresh\">identifier if the event called by subform refresh</param>\r\n  async handleInternalEventWithTaskAndSubformRefresh(itask: ITask, eventCode: number, subformRefresh: boolean): Promise<void> {\r\n    let task: Task = <Task>itask;\r\n\r\n    // set SubformExecMode (for SubformExecMode function) only in record prefix.\r\n    // SubformExecMode is changed in record prefix and it is the same until the\r\n    // next record prefix execution, because we do not open a subform task each time\r\n    // in RC as it is in Online. But when the subform is refreshed from the parent\r\n    // its record prefix & suffix are also executed.\r\n    if (eventCode === InternalInterface.MG_ACT_REC_PREFIX && task.IsSubForm && task.SubformExecMode !== Task_SubformExecModeEnum.FIRST_TIME)// FIRST_TIME is set only once in\r\n    // doFirstRecordCycle.\r\n    {\r\n      task.SubformExecMode = (subformRefresh ? Task_SubformExecModeEnum.REFRESH : Task_SubformExecModeEnum.SET_FOCUS);\r\n    }\r\n\r\n    // for the subform refresh it is needed to execute MG_ACT_POST_REFRESH_BY_PARENT handler before RECORD_PREFIX handler\r\n    if (subformRefresh)\r\n      await this.handleInternalEventWithTask(itask, InternalInterface.MG_ACT_POST_REFRESH_BY_PARENT);\r\n\r\n    if (task.DataView.isEmptyDataview()) {\r\n      if (eventCode === InternalInterface.MG_ACT_REC_PREFIX || eventCode === InternalInterface.MG_ACT_REC_SUFFIX) {\r\n        if (eventCode === InternalInterface.MG_ACT_REC_PREFIX)\r\n          await task.emptyDataviewOpen(subformRefresh);\r\n        else\r\n          task.emptyDataviewClose();\r\n\r\n        if (task.getForm() !== null) {\r\n          if (eventCode === InternalInterface.MG_ACT_REC_PREFIX)\r\n            await (<MgForm>task.getForm()).RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n          task.getForm().SelectRow();\r\n        }\r\n      } else\r\n        await this.handleInternalEventWithTaskAndEventSubtype(task, eventCode, EventSubType.Normal);\r\n    } else\r\n      await this.handleInternalEventWithTaskAndEventSubtype(task, eventCode, EventSubType.Normal);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   activate handleInternalEvent with isQuit = false\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">a reference to the control </param>\r\n  /// <param name = \"eventCode\">the code of the event </param>\r\n  async handleInternalEventWithMgControlBase(ctrl: MgControlBase, eventCode: number): Promise<void> {\r\n    await this.handleInternalEventWithMgControl(<MgControl>ctrl, eventCode, EventSubType.Normal);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the value of the \"stop execution\" flag\r\n  /// </summary>\r\n  GetStopExecutionFlag(): boolean {\r\n    return this._stopExecution;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the ctrl on which we had a \"stop execution\"\r\n  /// </summary>\r\n  private getStopExecutionCtrl(): MgControlBase {\r\n    return this._stopExecutionCtrl;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   initializes the static section of the events manager. Usually does nothing but in the\r\n  ///   event of applet re-load (for example, because of a browser refresh) it initializes the\r\n  ///   static part of this class.\r\n  /// </summary>\r\n  Init(): void {\r\n    if (this._initialized) {\r\n      this._isHandlingForceExit = false;\r\n      this._forceExit = ForceExit.None;\r\n      this._forceExitTask = null;\r\n      this._currField = null;\r\n      this.setEndOfWork(true);\r\n    }\r\n    this._initialized = true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Add internal event to the queue\r\n  /// </summary>\r\n  /// <param name = \"itask\">task</param>\r\n  /// <param name = \"code\">code of internal event</param>\r\n  addInternalEventWithItaskAndCode(itask: ITask, code: number): void {\r\n    this.addGuiTriggeredEventWithTaskAndCodeAndOnMultiMark(itask, code);\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <param name = \"code\"></param>\r\n  /// <returns></returns>\r\n  addInternalEventWithCtrlAndCode(ctrl: MgControlBase, code: number): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(<MgControl>ctrl);\r\n    rtEvt.setInternal(code);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <param name = \"code\"></param>\r\n  /// <returns></returns>\r\n  addInternalEventWithCtrlAndDisplayLineAndCode(ctrl: MgControlBase, DisplayLine: number, code: number): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(<MgControl>ctrl, DisplayLine, false);\r\n    rtEvt.setInternal(code);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"code\"></param>\r\n  /// <param name=\"priority\"></param>\r\n  addInternalEventWithCtrlAndCodeAndPriority(ctrl: MgControlBase, code: number, priority: Priority): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(<MgControl>ctrl);\r\n    rtEvt.setInternal(code);\r\n    rtEvt.setPriority(priority);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  /// add gui triggered event\r\n  /// </summary>\r\n  /// <param name=\"itask\"></param>\r\n  /// <param name=\"code\"></param>\r\n  /// <param name=\"onMultiMark\"></param>\r\n  addGuiTriggeredEventWithTaskAndCodeAndOnMultiMark(itask: ITask, code: number): void {\r\n    let task: Task = <Task>itask;\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(task);\r\n    rtEvt.setInternal(code);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  /// will be used for multimarking in the future\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"code\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"modifiers\"></param>\r\n  addGuiTriggeredEventWithCtrlAndCodeAndLineAndModifier(ctrl: MgControlBase, code: number, line: number): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(<MgControl>ctrl, line, false);\r\n    rtEvt.setInternal(code);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Add internal event that was triggered by GUI queue (includes timer events) to the queue\r\n  /// </summary>\r\n  /// <param name = \"task\">control </param>\r\n  /// <param name = \"code\">code of internal event </param>\r\n  /// <param name = \"line\">line in a table control </param>\r\n  addGuiTriggeredEventWithTaskAndCodeAndLine(task: Task, code: number, line: number): void {\r\n    let tsk: Task = null;\r\n    if (task !== null)\r\n      tsk = <Task>task;\r\n\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(tsk);\r\n    rtEvt.setInternal(code);\r\n    rtEvt.DisplayLine = line;\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary> handle Column Click event on Column </summary>\r\n  /// <param name=\"guiColumnCtrl\"></param>\r\n  /// <param name=\"direction\"></param>\r\n  /// <param name=\"columnHeader\"></param>\r\n  AddColumnClickEvent(columnCtrl: MgControlBase, direction: number, columnHeader: string): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(<MgControl>columnCtrl, direction, 0);\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_COL_CLICK);\r\n\r\n    // Prepare an argument list with argument as columnHeaderString.\r\n    let argsList = new Array<ExpVal>();\r\n    argsList[0] = new ExpVal(StorageAttribute.UNICODE, false, columnHeader);\r\n    let args = new ArgumentsList(argsList);\r\n    rtEvt.setArgList(args);\r\n\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  AddRouteEvent(task: ITask, code: number, routerpath: string, routerOutletName: string, routeParams: List<any>) {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(<Task>task, true);\r\n    rtEvt.setInternal(code);\r\n\r\n    let argsList: ExpVal[] = new Array<ExpVal>(2);\r\n    argsList[0] = new ExpVal(StorageAttribute.ALPHA, false, routerpath);\r\n    if (routerOutletName === null)\r\n      routerOutletName = '';\r\n    argsList[1] = new ExpVal(StorageAttribute.ALPHA, false, routerOutletName);\r\n\r\n    let args = new ArgumentsList(argsList);\r\n    rtEvt.setArgList(args);\r\n    rtEvt.setRouteParamList(routeParams);\r\n\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  AddRouterClosedEvent(task: Task) {\r\n    let subFormControl: MgControlBase = <MgControlBase>task.getForm().getSubFormCtrl();\r\n    let rtEvt = new RunTimeEvent(<TaskBase>subFormControl.getForm().getTask(), true);\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_SUBFORM_CLOSE);\r\n\r\n    let argsList: ExpVal[] = new Array<ExpVal>(1);\r\n    argsList[0] = new ExpVal(StorageAttribute.ALPHA, false, subFormControl.getName());\r\n\r\n    let args = new ArgumentsList(argsList);\r\n    rtEvt.setArgList(args);\r\n    EventsManager.Instance.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary> add last saved route event </summary>\r\n  /// <param name=\"srcTaskStr\"></param>\r\n  /// <param name=\"argListStr\"></param>\r\n  AddLastSavedRouteEvent(srcTask: Task, args: ArgumentsList) {\r\n    let rtEvt = new RunTimeEvent(<TaskBase>LastFocusedManager.Instance.getLastFocusedTask(), true);\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_WEBCLIENT_ROUTE);\r\n\r\n    if (srcTask != null) {\r\n      rtEvt.setTask(srcTask);\r\n      if (args != null) {\r\n        rtEvt.setArgList(args);\r\n      }\r\n      this.setLastSavedRouteEvent(rtEvt);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///  Add internal event ro set the value of control\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"> control </param>\r\n  /// <param name = \"value\"> value of control </param>\r\n  /// <param name = \"refreshDisplay\"> refresh display </param>\r\n  AddExternalValueEvent(ctrl: MgControl, value: any, refreshDisplay: boolean) {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(ctrl, 0, true);\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_SET_EXTERNAL_VALUE);\r\n    rtEvt.setValue(value);\r\n\r\n    let argsList: ExpVal[] = new Array<ExpVal>(1);\r\n    argsList[0] = new ExpVal(StorageAttribute.BOOLEAN, false, refreshDisplay ? '1' : '0');\r\n    let args = new ArgumentsList(argsList);\r\n    rtEvt.setArgList(args);\r\n\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Add internal event that was triggered by GUI queue (includes timer events) to the queue\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">control </param>\r\n  /// <param name = \"code\">code of internal event </param>\r\n  /// <param name = \"line\">line in a table control </param>\r\n  addGuiTriggeredEventWithCtrlAndCodeAndLine(ctrl: MgControlBase, code: number, line: number): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(ctrl, line, true);\r\n    rtEvt.setInternal(code);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Add internal event that was triggered by GUI queue (includes timer events) to the queue\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">control </param>\r\n  /// <param name = \"line\">the line for multiline control </param>\r\n  /// <param name = \"code\">code of internal event </param>\r\n  addGuiTriggeredEventWithCtrlAndLineAndCodeAndIsProductClick(ctrl: MgControlBase, code: number, line: number, isProduceClick: boolean): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(ctrl, line, true);\r\n    rtEvt.setInternal(code);\r\n    rtEvt.setProduceClick(isProduceClick);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Add internal event that was triggered by GUI queue (includes timer events) to the queue\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">control </param>\r\n  /// <param name = \"code\">code of internal event </param>\r\n  /// <param name = \"list\"></param>\r\n  addGuiTriggeredEventWithCtrlAndCodeAndList(ctrl: MgControlBase, code: number, list: List<MgControlBase>): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(ctrl, list, true);\r\n    rtEvt.setInternal(code);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary> Add internal event that was triggered by GUI queue to the queue </summary>\r\n  /// <param name = \"task\">reference to the task </param>\r\n  /// <param name = \"code\">code of internal event </param>\r\n  addGuiTriggeredEventWithTaskAndCode(task: ITask, code: number): void {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(<Task>task, true);\r\n    rtEvt.setInternal(code);\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary> Add internal event that was triggered by GUI queue to the queue </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"code\"></param>\r\n  /// <param name=\"raisedBy\">relevant only for online (for which subform are handled as orphans)</param>\r\n  addGuiTriggeredEventTaskAndCodeAndRaisedBy(task: ITask, code: number): void {\r\n    this.addGuiTriggeredEventWithTaskAndCode(task, code);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the first event from the queue and remove it from there\r\n  /// </summary>\r\n  private getEvent(): RunTimeEvent {\r\n    return <RunTimeEvent>this._eventsQueue.poll();\r\n  }\r\n\r\n  getForceExit(): ForceExit {\r\n    return this._forceExit;\r\n  }\r\n\r\n  private setForceExit(forceExit: ForceExit, task: Task): void {\r\n    this._forceExit = forceExit;\r\n    this.setForceExitTask(task);\r\n  }\r\n\r\n  private getForceExitTask(): Task {\r\n    return this._forceExitTask;\r\n  }\r\n\r\n  private setForceExitTask(task: Task): void {\r\n    this._forceExitTask = task;\r\n  }\r\n\r\n  /**\r\n   * returns true if the EventsManager is currently handling a user event with\r\n   * Force Exit = 'Pre-Record Update'\r\n   */\r\n  isForceExitPreRecordUpdate(task: TaskBase): boolean {\r\n    return this._isHandlingForceExit && this.getForceExit() === ForceExit.PreRecordUpdate && task === this.getForceExitTask();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Execute ClientContextInactivity Timer\r\n  /// </summary>\r\n  async ExecuteClientContextInactivityTimer(): Promise<void> {\r\n    let startTime = Misc.getSystemMilliseconds();\r\n\r\n    // convert tenths of seconds to milliseconds.\r\n    let clientCtxInactivityTimeout =\r\n      Environment.Instance.getClientContextInactivityTimeout() * 100;\r\n\r\n    EventsManager.clientInactivityTimerON = true;\r\n    while (EventsManager.clientInactivityTimerON) {\r\n      await Thread.Sleep(1000);\r\n      var timeLapsed = Misc.getSystemMilliseconds() - startTime;\r\n      if (EventsManager.clientContextInactivityTimerAborted || timeLapsed >= clientCtxInactivityTimeout) {\r\n        EventsManager.clientInactivityTimerON = false;\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Show or hide the spinner\r\n  /// </summary>\r\n  /// <param name = \"show\"> </param>\r\n  async CheckAndShowSpinner(show: boolean): Promise<void> {\r\n    let sendCommand = false;\r\n\r\n    // If the current event is of lowest priority, it is actually safe to open user interaction.\r\n    // So, stop the spinner.\r\n    if (this.getLastRtEvent() !== null && this.getLastRtEvent().getPriority() === Priority.LOWEST)\r\n      show = false;\r\n\r\n    if (show != this.isSpinnerShown) {\r\n      if (show) {\r\n        // Show the spinner only if threshold is reached.\r\n        //ToDo: Define a const for 1000. Also make it customizable from angular app\r\n        if (Misc.getSystemMilliseconds() - this.GetEventTime() > 1000) {\r\n          sendCommand = true;\r\n          EventsManager.clientBusyTimeStart = Misc.getSystemMilliseconds();\r\n        }\r\n      } else\r\n        sendCommand = true;\r\n\r\n      if (sendCommand) {\r\n        Commands.addShowSpinner(show);\r\n        Commands.beginInvoke();\r\n        // release the thread so that framework can show/hide the spinner\r\n        await Thread.Sleep(50);\r\n\r\n        this.isSpinnerShown = show;\r\n\r\n        if (!this.isSpinnerShown) {\r\n          // update the time for which client was busy\r\n          let totalClientBusyTime = Misc.getSystemMilliseconds() - EventsManager.clientBusyTimeStart;\r\n          this.SpinnerStopped.next(totalClientBusyTime);\r\n          EventsManager.clientBusyTimeStart = 0;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Main events loop, runs in worker thread for main window and for every\r\n  ///   modal window Responsible for handling events\r\n  /// </summary>\r\n  /// <param name = \"mgData\"> </param>\r\n  async EventsLoop(mgData: MGData): Promise<void> {\r\n    let savedAllowEvents: EventsAllowedType = this.getAllowEvents();\r\n\r\n    this.setAllowEvents(EventsAllowedType.ALL);\r\n\r\n    this.pushNewExecStacks();\r\n\r\n    while (!mgData.IsAborting) {\r\n      // Hide the spinner before moving to idle\r\n      await this.CheckAndShowSpinner(false);\r\n\r\n      await this._eventsQueue.waitForElement();\r\n      await this.handleEvents(mgData, 0);\r\n\r\n      if (!mgData.IsAborting)\r\n        await this.checkParkability();\r\n\r\n    }\r\n\r\n    this.popNewExecStacks();\r\n    this.setAllowEvents(savedAllowEvents);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Non interactive events loop, runs in worker thread for non interactive tasks\r\n  ///   Responsible for cycling forward on records and handling events.\r\n  /// </summary>\r\n  /// <param name = \"mgData\"></param>\r\n  async NonInteractiveEventsLoop(mgData: MGData, taskBase: TaskBase): Promise<void> {\r\n    let task: Task = <Task>taskBase;\r\n    let savedAllowEvents: EventsAllowedType = this.getAllowEvents();\r\n\r\n    this.setNonInteractiveAllowEvents(await task.isAllowEvents());\r\n\r\n    this.pushNewExecStacks();\r\n\r\n    while (!mgData.IsAborting) {\r\n      if (task.getMode() === Constants.TASK_MODE_DELETE)\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_CYCLE_NEXT_DELETE_REC);\r\n      else\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_CYCLE_NEXT_REC);\r\n\r\n      await Thread.Sleep(10);\r\n\r\n      // poll only 1 event.\r\n      if (!mgData.IsAborting && await task.isAllowEvents())\r\n        await this.handleEvents(mgData, 1);\r\n    }\r\n\r\n    this.popNewExecStacks();\r\n    this.setAllowEvents(savedAllowEvents);\r\n  }\r\n\r\n  async handleEvents(baseMgData: MGData, eventsToHandleCnt: number): Promise<void> ;\r\n  async handleEvents(handlersTab: HandlersTable, rtEvt: RunTimeEvent): Promise<void> ;\r\n  async handleEvents(baseMgDataOrHandlersTab: any, eventsToHandleCntOrRtEvt: any): Promise<void> {\r\n    if ((baseMgDataOrHandlersTab === null || baseMgDataOrHandlersTab instanceof MGData) && (eventsToHandleCntOrRtEvt === null || eventsToHandleCntOrRtEvt.constructor === Number)) {\r\n      await this.handleEvents_0(baseMgDataOrHandlersTab, eventsToHandleCntOrRtEvt);\r\n      return;\r\n    }\r\n    await this.handleEvents_1(baseMgDataOrHandlersTab, eventsToHandleCntOrRtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get and remove events from the queue and handle them one by one till the queue is empty\r\n  /// </summary>\r\n  /// <param name = \"baseMgData\"> mgdata of the window that openeded that habdle event</param>\r\n  /// <param name = \"EventsToHandleCnt\"></param>\r\n  private async handleEvents_0(baseMgData: MGData, eventsToHandleCnt: number): Promise<void> {\r\n    let task: Task = null;\r\n    let delta: number = 0;\r\n    let eventsPolledCnt: number = 0;\r\n\r\n    this.setStopExecution(false);\r\n\r\n    // get and remove events from the queue till its empty\r\n    while (!this._eventsQueue.isEmpty() && !this._stopExecution && (eventsToHandleCnt === 0 || eventsPolledCnt < eventsToHandleCnt)) {\r\n      let rtEvt: RunTimeEvent = this.getEvent();\r\n      if (rtEvt !== null && rtEvt.isGuiTriggeredEvent()) {\r\n        delta = Misc.getSystemMilliseconds();\r\n        this._currKbdItem = null;\r\n\r\n        let blockedByModalWindow: boolean = rtEvt.isBlockedByModalWindow(baseMgData);\r\n        if (blockedByModalWindow && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_TIMER) // QCR #726198, events from .NET objects which are not on form\r\n        // should be handled on parent of modal window also\r\n        {\r\n          continue;\r\n        }\r\n\r\n        // Idle timer, timer events and enable/disable events should not change the current window.\r\n        // This is because the current window determines the current task and changing the task\r\n        // causes some task-scoped events to run on sub-tasks as well.\r\n        if (!rtEvt.isIdleTimer() && !blockedByModalWindow && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_ENABLE_EVENTS && rtEvt.getInternalCode() !== InternalInterface.MG_ACT_DISABLE_EVENTS && rtEvt.getTask() !== null && !rtEvt.getTask().getMGData().IsAborting) {\r\n          MGDataCollection.Instance.currMgdID = rtEvt.getTask().getMGData().GetId();\r\n        }\r\n      }\r\n      let currMgd: MGData = MGDataCollection.Instance.getCurrMGData();\r\n      if (currMgd !== null) {\r\n        while (currMgd !== null && currMgd.IsAborting) {\r\n          currMgd = currMgd.getParentMGdata();\r\n          if (currMgd !== null)\r\n            MGDataCollection.Instance.currMgdID = MGDataCollection.Instance.getMgDataIdx(currMgd);\r\n        }\r\n      } else {\r\n        /* QCRs #777217 & #942968                             */\r\n        /* It might happen that we have removed the MGData    */\r\n        /* from the MGTable in Manager.CloseEvent().  */\r\n        /* It was done for fixing QCR# 296277 relating to mem */\r\n        /* leaks.                                             */\r\n        /* In that case, mgd would be null here.              */\r\n        /* In such a scenario, take the parent mgd from the   */\r\n        /* related task and continue processing the events.   */\r\n        task = <Task>rtEvt.getTask();\r\n        while (currMgd === null && task !== null && task.getParent() !== null) {\r\n          task = <Task>task.getParent();\r\n          currMgd = task.getMGData();\r\n          if (currMgd.IsAborting)\r\n            currMgd = null;\r\n\r\n          if (currMgd !== null)\r\n            MGDataCollection.Instance.currMgdID = MGDataCollection.Instance.getMgDataIdx(currMgd);\r\n        }\r\n      }\r\n      if (currMgd === null)\r\n        break;\r\n\r\n      if (rtEvt.getTask() === null) {\r\n        task = LastFocusedManager.Instance.getLastFocusedTask();\r\n        while (task !== null && (task.isAborting() || task.InEndTask))\r\n          task = <Task>task.getParent();\r\n\r\n        if (task !== null) {\r\n          rtEvt.setCtrl(<MgControl>task.getLastParkedCtrl());\r\n          rtEvt.setTask(task);\r\n        }\r\n      } else\r\n        task = <Task>rtEvt.getTask();\r\n\r\n      if (task !== null) {\r\n        await this.handleEvent(rtEvt, false);\r\n      }\r\n\r\n      GUIManager.Instance.execGuiCommandQueue();\r\n      this._currCtrl = null; // delete current processed control\r\n\r\n      if (task !== null)\r\n        await Task.CommandsProcessor.SendMonitorOnly();\r\n      else {\r\n\r\n        await Task.CommandsProcessor.SendMonitorOnly();\r\n      }\r\n\r\n      if (rtEvt !== null && rtEvt.isGuiTriggeredEvent()) {\r\n        // logging for performance\r\n        if (delta > 0) {\r\n          delta = Misc.getSystemMilliseconds() - delta;\r\n        }\r\n      }\r\n\r\n      // advance EventsPolled only if the event is internal. otherwise internals to be executed will be never reached by non interactive tasks.\r\n      if (eventsToHandleCnt > 0 && rtEvt !== null && rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.InternalEvent < InternalInterface.MG_ACT_TOT_CNT)\r\n        eventsPolledCnt++;\r\n    } // while (!_eventsQueue.isEmpty() ...\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Handle stop execution while executing any handler\r\n  /// </summary>\r\n  /// <param name = \"rtEvt\"></param>\r\n  /// <returns></returns>\r\n  private async handleStopExecution(rtEvt: RunTimeEvent): Promise<boolean> {\r\n    let stop: boolean = false;\r\n\r\n    if (!this.GetStopExecutionFlag())\r\n      return stop;\r\n\r\n    let task: Task = <Task>rtEvt.getTask();\r\n    let currCtrl: MgControl = <MgControl>rtEvt.Control;\r\n    let lastParkedCtrl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n    let endTaskDueToVerifyError: boolean = false;\r\n    if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {\r\n      switch (rtEvt.getInternalCode()) {\r\n        case InternalInterface.MG_ACT_TASK_PREFIX:\r\n          endTaskDueToVerifyError = true;\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_REC_PREFIX:\r\n          // An error in the record prefix sends us right back to the start of the record prefix.\r\n          // It might create an endless loop but it is OK to do so. It is a developer bug.\r\n          endTaskDueToVerifyError = true;\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_REC_SUFFIX:\r\n          // it will be handled in commonhandlerafter\r\n          this.setStopExecutionCtrl(null);\r\n          this.setStopExecutionCtrl(<MgControl>task.getLastParkedCtrl());\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_PREFIX:\r\n          // Error might have occurred in CP.\r\n          this.setStopExecution(false);\r\n          task.InCtrlPrefix = false;\r\n\r\n          if (lastParkedCtrl === null)\r\n          // only for the first time\r\n          {\r\n            task.setCurrField(null);\r\n\r\n            // reset the stop execution ctrl\r\n            this.setStopExecutionCtrl(null);\r\n            this.setStopExecutionCtrl(currCtrl);\r\n\r\n            await this.HandleNonParkableControls(task);\r\n          } else {\r\n            // CP got stop execution while executing the operations in this handler and is parkable.\r\n            // we move to the LastParkable control\r\n\r\n            task.setCurrField(lastParkedCtrl.getField());\r\n\r\n            await FocusManager.SetFocus(lastParkedCtrl, -1);\r\n          }\r\n          this.setStopExecution(true);\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_SUFFIX:\r\n          // It must be set to false so that next time for fast mode CS must be executed.\r\n          currCtrl.setInControlSuffix(false);\r\n          break;\r\n\r\n      }\r\n      if (endTaskDueToVerifyError) {\r\n        await task.endTask(true, false, true);\r\n        stop = true;\r\n      }\r\n    }\r\n    return stop;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   take care of \"Force Exit\" before the handler execute its operations returns true\r\n  ///   if the force exit was handled\r\n  /// </summary>\r\n  /// <param name = \"event\">the event of the handler\r\n  /// </param>\r\n  /// <param name = \"rtEvt\">the run-time event\r\n  /// </param>\r\n  private async handleForceExitBefore(evt: Event, rtEvt: RunTimeEvent): Promise<boolean> {\r\n    let forceExit: ForceExit = evt.UserEvt.ForceExit;\r\n    let isNewRec: boolean = false;\r\n    let oldIdx: number = 0;\r\n\r\n    // TODO: check the effect of removing forceExit === <ForceExit>0\r\n    if (forceExit === ForceExit.None || rtEvt.isImmediate())\r\n      return false;\r\n    this._isHandlingForceExit = true;\r\n    let task: Task = <Task>rtEvt.getTask();\r\n    let oldRec: Record = (<DataView>task.DataView).getCurrRec();\r\n    if (oldRec !== null && oldRec.getMode() === DataModificationTypes.Insert && oldRec.isNewRec()) {\r\n      isNewRec = true;\r\n      oldIdx = oldRec.getId();\r\n    }\r\n    if (forceExit !== ForceExit.Editing && task.getLevel() === Constants.TASK_LEVEL_CONTROL) {\r\n      let ctrl: MgControl = <MgControl>task.getLastParkedCtrl();\r\n      if (ctrl !== null)\r\n        await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n    }\r\n\r\n    // Should we exit the record?\r\n    if ((forceExit === ForceExit.PreRecordUpdate || forceExit === ForceExit.PostRecordUpdate) && task.getLevel() === Constants.TASK_LEVEL_RECORD) {\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n      if (task.getMode() === Constants.TASK_MODE_CREATE && !this._stopExecution)\r\n        task.setMode(Constants.TASK_MODE_MODIFY);\r\n      let currRec: Record = (<DataView>task.DataView).getCurrRec();\r\n      // If we failed exiting a newly created record - restore insert mode of the record\r\n      if (currRec !== null && this._stopExecution && isNewRec && oldIdx === currRec.getId() && task.getMode() === Constants.TASK_MODE_CREATE) {\r\n        // restore insert mode of the record\r\n        currRec.clearMode();\r\n        currRec.restart(DataModificationTypes.Insert);\r\n      }\r\n    }\r\n    if (forceExit === ForceExit.PostRecordUpdate && !this._stopExecution) {\r\n      if (task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n    }\r\n\r\n    // QCR #303762 - additional support for forceExit = editing\r\n    if (forceExit === ForceExit.Editing) {\r\n      let evtCtrl: MgControl = <MgControl>rtEvt.Control;\r\n\r\n      if (evtCtrl !== null && evtCtrl.getField() !== null) {\r\n        let ctrlVal: string = Manager.GetCtrlVal(evtCtrl);\r\n        // test the new control value\r\n        await evtCtrl.validateAndSetValue(ctrlVal, true);\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   take care of \"Force Exit\" after handling the event </summary>\r\n  /// <param name = \"rtEvt\">the run-time event </param>\r\n  private async handleForceExitAfter(rtEvt: RunTimeEvent): Promise<void> {\r\n    let forceExit: ForceExit = rtEvt.UserEvt.ForceExit;\r\n\r\n    let task: Task = <Task>rtEvt.getTask();\r\n\r\n    // QCR#776295: for pre record update, commit the record after handler's execution.\r\n    if (forceExit === ForceExit.PreRecordUpdate) {\r\n      await this.commitRecord(task, true);\r\n      if (!task.transactionFailed(ConstInterface.TRANS_RECORD_PREFIX) && !task.isAborting()) {\r\n        // check whether to evaluate the end condition after the record suffix\r\n        if (await task.evalEndCond(ConstInterface.END_COND_EVAL_AFTER))\r\n          await task.endTask(true, false, false);\r\n      }\r\n    }\r\n\r\n    // For post-record type we already did rec-prefix and ctrl prefix in the handleForceExitBefore\r\n    if (forceExit !== ForceExit.PostRecordUpdate) {\r\n      task = <Task>rtEvt.getTask();\r\n      if (task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n    }\r\n    let ctrl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n    if (ctrl !== null && forceExit !== ForceExit.Editing) {\r\n      await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_PREFIX);\r\n    }\r\n\r\n    // QCR 801873 - update the display after handler of force exit editing\r\n    if (forceExit === ForceExit.Editing) {\r\n      let evtCtrl: MgControl = <MgControl>rtEvt.Control;\r\n      // if there is a control that is attached to a field\r\n      if (evtCtrl !== null && evtCtrl.getField() !== null)\r\n        await (<Field>evtCtrl.getField()).updateDisplay();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   a special routine to handle data and timer events\r\n  ///   it receives a HandlersTable and execute them one by one\r\n  /// </summary>\r\n  /// <param name = \"handlersTab\">the handlers table</param>\r\n  /// <param name = \"rtEvt\">a referennce to the timer runtime event - for expression events it must be null</param>\r\n  private async handleEvents_1(handlersTab: HandlersTable, rtEvt: RunTimeEvent): Promise<void> {\r\n    try {\r\n      this.pushRtEvent(rtEvt);\r\n      for (let i: number = 0; i < handlersTab.getSize(); i++) {\r\n        let handler: EventHandler = handlersTab.getHandler(i);\r\n        // the rtEvt is used to pass the ctrl, therefor it must be valid (not null)\r\n        if (rtEvt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION || handler.isSpecificHandlerOf(rtEvt) || handler.isNonSpecificHandlerOf(rtEvt) || handler.isGlobalHandlerOf(rtEvt)) {\r\n          await handler.execute(rtEvt, false, false);\r\n        }\r\n      }\r\n    } finally {\r\n      this.popRtEvent();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Takes care of keydown Event\r\n  /// </summary>\r\n  /// <param name = \"task\">task</param>\r\n  /// <param name = \"ctrl\">control pressed</param>\r\n  /// <param name = \"kbdItem\">keybord item</param>\r\n  private async handleKeyDown(task: Task, ctrl: MgControl, evt: RunTimeEvent): Promise<void> {\r\n    let kbdItem: KeyboardItem = evt.getKbdItmAlways();\r\n    let keyCode: number = kbdItem.getKeyCode();\r\n    this._currKbdItem = kbdItem;\r\n\r\n    // If keyboard buffering is responsible for this event, we need to find the right control to receive\r\n    // this event\r\n    if (evt.IgnoreSpecifiedControl) {\r\n      ctrl = this.getCurrCtrl();\r\n      task = (((ctrl.getForm().getTask() instanceof Task) ? <Task>ctrl.getForm().getTask() : null));\r\n      // The control receiving keys from keyboard buffering must be a textbox\r\n      if (ctrl.Type !== MgControlType.CTRL_TYPE_TEXT)\r\n        return;\r\n    }\r\n\r\n    Logger.Instance.WriteDevToLog('Start handling KEYDOWN event. Key code: ' + keyCode);\r\n\r\n    try {\r\n\r\n      // DOWN or UP invoked on a SELECT/RADIO control\r\n      if (this._currKbdItem.equals(this.KBI_DOWN) || this._currKbdItem.equals(this.KBI_UP)) {\r\n        if (ctrl !== null && (ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO))\r\n          return;\r\n      }\r\n\r\n      let rtEvt: RunTimeEvent = new RunTimeEvent(task, ctrl);\r\n      rtEvt.setSystem(this._currKbdItem);\r\n      rtEvt.setEditParms(evt.getStartSelection(), evt.getEndSelection(), evt.getValue());\r\n      try {\r\n        await this.handleEvent(rtEvt, false);\r\n      } finally {\r\n        if (this._stopExecution) {\r\n          let returnToCtrl: MgControl = MgControl.ReturnToCtrl;\r\n          if (returnToCtrl !== null && MgControl.validReturnToCtrl())\r\n            returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);\r\n        }\r\n      }\r\n      let mgd: MGData = MGDataCollection.Instance.getCurrMGData();\r\n      // check if the MGData is still alive after handling the events above\r\n      if (mgd !== null && !mgd.IsAborting)\r\n        await this.handleExpressionHandlers();\r\n      Logger.Instance.WriteDevToLog('End handling KEYDOWN event. Key code: ' + keyCode);\r\n      // if a key was pressed on table child, make sure that is is visible\r\n      if (ctrl !== null && ctrl.IsRepeatable && ctrl === MgControl.ReturnToCtrl) {\r\n        await (<MgForm>ctrl.getForm()).bringRecordToPage();\r\n      }\r\n    } finally {\r\n    }\r\n  }\r\n\r\n  /// <summary>Handle Selection Event</summary>\r\n  /// <param name = \"ctrl\">control</param>\r\n  /// <param name = \"line\">line</param>\r\n  /// <param name = \"value\">value</param>\r\n  private async handleSelection(ctrl: MgControl, line: number, val: any): Promise<void> {\r\n    if (ctrl.Type === MgControlType.CTRL_TYPE_TAB || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_COMBO || ctrl.Type === MgControlType.CTRL_TYPE_LIST) {\r\n      let checkFocus: boolean = (ctrl.Type !== MgControlType.CTRL_TYPE_TAB && ctrl.Type !== MgControlType.CTRL_TYPE_CHECKBOX);\r\n      let allowSelection: boolean = (checkFocus ? (ctrl.getForm().getTask().getLastParkedCtrl() === ctrl) : true);\r\n\r\n      if (!allowSelection || !ctrl.isModifiable() || !await ctrl.IsParkable())\r\n        await ctrl.restoreOldValue();\r\n      else {\r\n        if (ctrl.isChoiceControl())\r\n          Commands.setGetSuggestedValueOfChoiceControlOnTagData(ctrl, ctrl.IsRepeatable ? line : 0, true);\r\n\r\n        if (ctrl.isDifferentValue(val, ctrl.IsNull, true)) {\r\n          // #931545 - var change must be invoked first before control verification.\r\n          ctrl.ModifiedByUser = true;\r\n          await this.handleCtrlModify(ctrl, InternalInterface.MG_ACT_SELECTION);\r\n        }\r\n\r\n        if (ctrl.isChoiceControl())\r\n          Commands.setGetSuggestedValueOfChoiceControlOnTagData(ctrl, ctrl.IsRepeatable ? line : 0, false);\r\n\r\n        // For multiple selection ListBox value to field and ctrl would be set on leaving\r\n        // control, before executing control suffix. So variable change internal event would be\r\n        // handled before executing control suffix.\r\n        if (!ctrl.IsMultipleSelectionListBox())\r\n          await ctrl.validateAndSetValue(val, true);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Handle Mouse Up Event\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">contol\r\n  /// </param>\r\n  /// <param name = \"line\">line of multiline control\r\n  /// </param>\r\n  /// <param name = \"produceClick\">if true, produce click event\r\n  /// </param>\r\n  private async handleMouseUp(ctrl: MgControl, line: number, produceClick: boolean): Promise<void> {\r\n    if (ctrl === null)\r\n      return;\r\n\r\n    // QCR # 6144 see documentation for the _currClickedRadio member\r\n    if (ctrl.Type === MgControlType.CTRL_TYPE_RADIO)\r\n      RuntimeContextBase.Instance.CurrentClickedRadio = ctrl;\r\n    try {\r\n      if (ctrl.Type !== MgControlType.CTRL_TYPE_TABLE) {\r\n        if (!await ctrl.checkPropWithLine(PropInterface.PROP_TYPE_ENABLED, true, line)) {\r\n          return;\r\n        }\r\n        let canGotoCtrl: boolean = this.canGoToControl(ctrl, true);\r\n        let StopFocus: boolean = ctrl.isFocusedStopExecution();\r\n\r\n        let returnToCtrl: MgControl = MgControl.ReturnToCtrl;\r\n\r\n        if ((!canGotoCtrl || ((this._stopExecution || StopFocus) && returnToCtrl !== ctrl)) && returnToCtrl !== null) {\r\n          MGDataCollection.Instance.currMgdID = (<Task>returnToCtrl.getForm().getTask()).getMgdID();\r\n          if (returnToCtrl.IsRepeatable)\r\n            await (<MgForm>returnToCtrl.getForm()).bringRecordToPage();\r\n          await FocusManager.SetFocus(returnToCtrl, -1);\r\n          returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);\r\n        }\r\n        if (this._stopExecution || StopFocus)\r\n          return;\r\n      }\r\n\r\n      if (produceClick && (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_LIST)) {\r\n        let rtEvt: RunTimeEvent = new RunTimeEvent(ctrl);\r\n        rtEvt.setInternal(InternalInterface.MG_ACT_WEB_CLICK);\r\n        this.addToTail(rtEvt);\r\n      }\r\n    } finally {\r\n      RuntimeContextBase.Instance.CurrentClickedRadio = null;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///  Check if ctx is removed from server, if so and current event is route event , then save it\r\n  //  to execute again when  server ctx is recreated\r\n  /// </summary>\r\n  checkAndSaveRouteEventIfCtxRemovedFromSrvr(aRtEvt: any): void {\r\n\r\n    if (aRtEvt.getType() == ConstInterface.EVENT_TYPE_INTERNAL && aRtEvt.getInternalCode() ==\r\n      InternalInterface.MG_ACT_WEBCLIENT_ROUTE && RuntimeContextBase.Instance.RemovedContextFromServer) {\r\n      this.setLastSavedRouteEvent(aRtEvt);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Handle Focus Event\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <param name = \"line\">line of multiline control</param>\r\n  /// <param name = \"onClick\"></param>\r\n  private async handleFocus(ctrl: MgControl, line: number, onClick: boolean): Promise<void> {\r\n    try {\r\n\r\n      if (ctrl.isStatic())\r\n        return;\r\n\r\n      // If we attempt to park on control where we do not want to allow to park like if control has expression or parent task field, do not allow to focus on it.\r\n      // Set Focus back to lastFocusedControl. We need _lastFailedFocusedControl as we get focus event on a control twice. So to avoid to show error multiple times,\r\n      // maintain _lastFailedFocusedControl.\r\n      if (ctrl !== this._lastFailedFocusedControl && ctrl.HasExpOrParentTaskField()) {\r\n        // Show error only for controls having Data property and parkable\r\n        if (ctrl.isListBox() || ctrl.isCheckBox() || ctrl.isComboBox() || ctrl.isTextControl() || ctrl.isRadio() || ctrl.isTabControl()) {\r\n          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));\r\n          // Defect 152728: Use last focused task instead control task as control can be from subform.\r\n          FocusManager.SetFocus(LastFocusedManager.Instance.getLastFocusedTask(), LastFocusedManager.getLastFocusedControl(), 0,\r\n            LastFocusedManager.getLastFocusedControl() === null ? true : false);\r\n          this._lastFailedFocusedControl = ctrl;\r\n          return;\r\n        }\r\n      }\r\n\r\n      this._lastFailedFocusedControl = null;\r\n\r\n      if (onClick)\r\n        RuntimeContextBase.Instance.CurrentClickedCtrl = ctrl;\r\n\r\n      let prevCtrl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n      if (ctrl === prevCtrl && !ctrl.isRepeatable()) {\r\n        await (<MgForm>ctrl.getForm()).bringRecordToPage();\r\n        // we received focus twice\r\n        return;\r\n      }\r\n\r\n      //check if last task is opened in Modal Subform, if yes, close it before focussing on parent task's ctrl\r\n      let prevTask: Task = <Task>LastFocusedManager.Instance.getLastFocusedTask();\r\n\r\n\r\n      if (ctrl === null || ctrl.Type === MgControlType.CTRL_TYPE_TABLE) {\r\n        if (prevCtrl === null)\r\n          await this.HandleNonParkableControls(ctrl.getForm().getTask());\r\n        return;\r\n      }\r\n\r\n      let currTask: Task;\r\n      if ((ctrl.Type === MgControlType.CTRL_TYPE_BUTTON) && (<RaiseAt>(await (ctrl.getProp(PropInterface.PROP_TYPE_RAISE_AT)).getValueInt()) === RaiseAt.TaskInFocus))\r\n        currTask = prevTask;\r\n      else\r\n        currTask = <Task>ctrl.getForm().getTask();\r\n\r\n      let canGotoCtrl: boolean = this.canGoToControl(ctrl, onClick);\r\n\r\n      // Go to the control - insert prefix\r\n      if (canGotoCtrl) {\r\n        // Modal subform task closing has already begun. Do not handle HandleSubformModality() again.\r\n        if (this.guiPendingEvent != null)\r\n          return;\r\n        let handled = await this.HandleSubformModality(ctrl, prevTask, currTask);\r\n        if (handled)\r\n          return;\r\n\r\n        let eventLine: number = (ctrl.isRepeatable() || ctrl.isRadio()) ? line : Int32.MinValue;\r\n        let rtEvt: RunTimeEvent = new RunTimeEvent(ctrl, eventLine);\r\n        rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_PREFIX);\r\n        await this.handleEvent(rtEvt, false);\r\n      } else if (prevCtrl !== null) {\r\n        if (!prevCtrl.isModifiable()) {\r\n          if (prevCtrl.isChoiceControl())\r\n            await prevCtrl.restoreOldValue();\r\n        } else if (!currTask.cancelWasRaised()) {\r\n          let newVal: string = Manager.GetCtrlVal(prevCtrl);\r\n          if (!await prevCtrl.validateAndSetValue(newVal, true))\r\n            this.setStopExecution(true);\r\n        }\r\n        MgControl.ReturnToCtrl = prevCtrl;\r\n      } else\r\n        await this.HandleNonParkableControls(ctrl.getForm().getTask());\r\n\r\n      if (!this._stopExecution && MgControl.ReturnToCtrl === ctrl)\r\n        LastFocusedManager.setLastFocusedControl(<TaskBase>ctrl.getForm().getTask(), ctrl);\r\n      return;\r\n    } finally {\r\n      ctrl.setFocusedStopExecution(this._stopExecution);\r\n      if (this._stopExecution) {\r\n        {\r\n          let returnToCtrl: MgControl = MgControl.ReturnToCtrl;\r\n\r\n          if (returnToCtrl !== null) {\r\n            MGDataCollection.Instance.currMgdID = (<Task>returnToCtrl.getForm().getTask()).getMgdID();\r\n            await FocusManager.SetFocus(returnToCtrl, -1);\r\n            returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  // <summary>\r\n  ///   Handle subform modality befor foucssing on parent ctrl\r\n  /// 1.if cursor is parked on modal subform task and user clicks on it's parent : close the subform task.\r\n  /// 2.if cursor is parked on modal subform 'S2' which is opened in another subform modal 'S1', then clicking on  parent'P1'\r\n  /// will close both S2 and S1.\r\n  /// 3.if cursor is parked on non modal subform 'S2' which is opened in subform modal 'S1', then clicking on S1, will not close S2\r\n  /// but clicking on P1 will close both S2 and S1.\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">ctrl to be focussed</param>\r\n  /// <param name = \"prevTask\">previous task which was in focus</param>\r\n  /// <param name = \"currTask\">current task which is to be focussed</param>\r\n\r\n  private async HandleSubformModality(ctrl: MgControl, prevTask: Task, currTask: Task): Promise<boolean> {\r\n    let handledSubformModality = false;\r\n\r\n    // evaluate the correct prevTask to be closed if it is Modal.\r\n    // if newly subform Modal task is opened and it is not yet focussed, in that case curr task is same as prevtask.\r\n    // now clicking on it's parent task, should close the Modal subform task\r\n    let length = prevTask.getMGData().getTasksCount();\r\n    let topTask: Task = prevTask.getMGData().getTask(length - 1);\r\n    if (currTask == prevTask || prevTask != topTask /* nested subform */) {\r\n      if (topTask != null && prevTask != topTask && topTask.IsSubForm) {\r\n        let subformCtrl: MgControl = <MgControl>topTask.getForm().getSubFormCtrl();\r\n        if (subformCtrl.IsModal())\r\n          prevTask = topTask;\r\n      }\r\n    }\r\n\r\n    // close subform task is Modal if to be parked on parent.\r\n    if (prevTask != <Task>ctrl.getForm().getTask() && prevTask.getIsDestinationCall()) {\r\n\r\n      if (!currTask.isDescendentOf(prevTask)) {\r\n        let subformCtrl: MgControl = <MgControl>prevTask.getForm().getSubFormCtrl();\r\n        if (!subformCtrl.IsModal() && !currTask.getIsDestinationCall())\r\n          subformCtrl = prevTask.GetSubformModalParentTask();\r\n        if (subformCtrl != null && (ctrl != subformCtrl) && subformCtrl.IsModal()) {\r\n\r\n          await this.performSubformClose(<MgControl>subformCtrl);\r\n          if (!this._stopExecution)\r\n            this.guiPendingEvent = this.getLastRtEvent();\r\n          handledSubformModality = true;\r\n        }\r\n      }\r\n    }\r\n\r\n    return handledSubformModality;\r\n  }\r\n\r\n  /// <summary>\r\n  ///  Calls Controls Suffix when focus on Non magic control i.e. control with MagicDummyControl is received\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">control</param>\r\n  /// <returns></returns>\r\n  private async handleFocusOnNonMagicControl(ctrl: MgControl): Promise<void> {\r\n    try {\r\n      await EventsManager.Instance.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n    } finally {\r\n      ctrl.setFocusedStopExecution(this._stopExecution);\r\n      if (this._stopExecution) {\r\n        {\r\n          let returnToCtrl: MgControl = MgControl.ReturnToCtrl;\r\n\r\n          if (returnToCtrl !== null) {\r\n            MGDataCollection.Instance.currMgdID = (<Task>returnToCtrl.getForm().getTask()).getMgdID();\r\n            await FocusManager.SetFocus(returnToCtrl, -1);\r\n            returnToCtrl.getForm().getTask().setLastParkedCtrl(returnToCtrl);\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if we can go to the control and try to park on in\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">control</param>\r\n  /// <param name = \"line\">line</param>\r\n  /// <param name = \"onClick\">real click is performed, this not click simulation</param>\r\n  /// <returns></returns>\r\n  private canGoToControl(ctrl: MgControl, onClick: boolean): boolean {\r\n\r\n    if (onClick && (ctrl.Type === MgControlType.CTRL_TYPE_SUBFORM || ctrl.Type === MgControlType.CTRL_TYPE_BROWSER))\r\n      return false;\r\n\r\n    // V9.4SP4d change of behavior - we do not \"exit\" from the current ctrl\r\n    // (i.e. not performing ctrl suffix or ctrl verifications) if the target ctrl\r\n    // is IMG or hypertext.\r\n    let canGotoCtrl: boolean = true;\r\n    let currTask: Task = <Task>ctrl.getForm().getTask();\r\n    // if cancel is raised , then do not go to next control before handling cancel event.\r\n    let lastTask: Task = LastFocusedManager.Instance.getLastFocusedTask();\r\n    if (!currTask.IsInteractive || (lastTask != null && lastTask.getLastParkedCtrl() != null &&\r\n      lastTask.cancelWasRaised()))\r\n      return false;\r\n\r\n    if (ctrl.Type === MgControlType.CTRL_TYPE_IMAGE && !ctrl.IsRepeatable)\r\n      canGotoCtrl = false;\r\n\r\n    return canGotoCtrl;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Handle Timer Events\r\n  /// </summary>\r\n  /// <param name = \"evt\">tuntime timer event</param>\r\n  private async handleTimer(evt: RunTimeEvent): Promise<void> {\r\n    evt.setType(ConstInterface.EVENT_TYPE_TIMER);\r\n    if (evt.isIdleTimer()) {\r\n      await this.handleExpressionHandlers();\r\n      await this.handleContextInactivityAlert(evt);\r\n    } else {\r\n      let mgd: MGData = MGDataCollection.Instance.getMGData(evt.getMgdID());\r\n      await this.handleEvents(mgd.getTimerHandlers(), evt);\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   When the context inactivity timeout is about to expire, raise a warning to user\r\n  //    so that the session can be continued\r\n  /// </summary>\r\n  /// <param name = \"evt\">tuntime timer event</param>\r\n  private async handleContextInactivityAlert(evt: RunTimeEvent): Promise<void> {\r\n    let timeNow: number = Misc.getSystemMilliseconds();\r\n    let mgd: MGData = evt.getTask().getMGData();\r\n    let lastRequestTime: number = RemoteCommandsProcessor.GetInstance().GetLastRequestTime;\r\n    let contextInactivityTimeout: number = Environment.Instance.getContextInactivityTimeout() / 10;\r\n    let contextInactivityWarningTime: number = Environment.Instance.getContextInactivityWarningTime() / 10;\r\n\r\n    let idleTime = (timeNow - lastRequestTime) / 1000;\r\n\r\n    // Display the confirmation only for valid timeouts\r\n    if (contextInactivityTimeout == 0 || contextInactivityWarningTime == 0)\r\n      return;\r\n\r\n    if (EventsManager.userGrantedForContextActivity && idleTime >= (contextInactivityTimeout - contextInactivityWarningTime)) {\r\n      // raise an alert to notify user when the context is about to be terminated\r\n      // if user clicks on OK, send dummy request to server. If Cancel is clicked, do nothing.\r\n      let userConfirmation: number = await GUIManager.Instance.MessageBox(this.confirmationDialogTitle, this.confirmationDialogMsg, Styles.MSGBOX_BUTTON_YES_NO);\r\n      if (userConfirmation == Styles.MSGBOX_RESULT_YES) {\r\n        // send request to server to mark the context inactivity timeout to zero\r\n        let cmd: IClientCommand = CommandFactory.CreateContextTimeoutResetEventCommand();\r\n        mgd.CmdsToServer.Add(cmd);\r\n        await RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);\r\n      } else {\r\n        EventsManager.userGrantedForContextActivity = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   process expression handlers\r\n  /// </summary>\r\n  async handleExpressionHandlers(): Promise<void> {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(LastFocusedManager.Instance.getLastFocusedTask(), LastFocusedManager.getLastFocusedControl());\r\n    rtEvt.setExpression(null);\r\n    rtEvt.setMainPrgCreator(rtEvt.getTask());\r\n    for (let i: number = 0; i < MGDataCollection.Instance.getSize(); i++) {\r\n      let mgd: MGData = MGDataCollection.Instance.getMGData(i);\r\n      if (mgd !== null && !mgd.IsAborting)\r\n        await this.handleEvents(mgd.getExpHandlers(), rtEvt);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   resize of page\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">table</param>\r\n  /// <param name = \"rowsInPage\"></param>\r\n  private handleResize(ctrl: MgControl, rowsInPage: number): void {\r\n    (<MgForm>ctrl.getForm()).setRowsInPage(rowsInPage);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get data for Row\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">\r\n  /// </param>\r\n  /// <param name = \"sendAll\">if true, send all records\r\n  /// </param>\r\n  /// <param name = \"row\">\r\n  /// </param>\r\n  private async handleRowDataCurPage(table: MgControl, desiredTopIndex: number, sendAll: boolean, lastFocusedVal: LastFocusedVal): Promise<void> {\r\n    let form: MgForm = <MgForm>table.getForm();\r\n    await form.setRowData(desiredTopIndex, sendAll);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   transfers data to GUI thread in free worker thread time\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  private async handleTransferDataToGui(ctrl: MgControl): Promise<void> {\r\n    let form: MgForm = <MgForm>ctrl.getForm();\r\n    await form.transferDataToGui();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Fetches the chunk from server,\r\n  ///   If the last records is not yet fetched it fetches the next chunk,\r\n  ///   Else, fetches the previous chunk\r\n  /// </summary>\r\n  private async fetchRecordsAheadFromServer(ctrl: MgControl): Promise<void> {\r\n    let form: MgForm = <MgForm>ctrl.getForm();\r\n    await form.FetchRecordsAheadFromServer();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   When internal act asks for enable/disable of an act list.\r\n  ///   call enableList with onlyIfChanged = true to minimize calls tos refresh.\r\n  /// </summary>\r\n  /// <param name = \"enable\"></param>\r\n  private handleEnableEvents(evt: RunTimeEvent, enable: boolean): void {\r\n    evt.getTask().ActionManager.enableList(evt.getActEnableList(), enable, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Handles control Prefix\r\n  /// </summary>\r\n  /// <param name = \"evt\"></param>\r\n  /// <returns></returns>\r\n  private async handleCtrlPrefix(evt: RunTimeEvent): Promise<boolean> {\r\n    let task: Task = <Task>evt.getTask();\r\n    let currClickedCtrl: MgControl = <MgControl>RuntimeContextBase.Instance.CurrentClickedCtrl;\r\n    let form: MgForm = <MgForm>task.getForm();\r\n    let displayLine: number = evt.getDisplayLine();\r\n    let ctrl: MgControl = <MgControl>evt.Control;\r\n\r\n    if (form.isLineMode()) {\r\n      if (displayLine === Int32.MinValue || ctrl.isRadio())\r\n        displayLine = form.DisplayLine;\r\n    } else\r\n      displayLine = Int32.MinValue;\r\n\r\n    let lastParkedCtrl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n\r\n    // prevent double prefix on the same control\r\n    // For Fast Mode, CS is executed from here, whereas for step mode it is done\r\n    // in moveInRow. so, for step mode double execution of CS must be stopped.\r\n    if (lastParkedCtrl !== null && (<Task>lastParkedCtrl.getForm().getTask()).getMGData().GetId() === (<Task>ctrl.getForm().getTask()).getMGData().GetId() && lastParkedCtrl.getForm().getTask().getLevel() === Constants.TASK_LEVEL_CONTROL) {\r\n      if ((ctrl !== lastParkedCtrl || (ctrl.isRepeatable() && displayLine !== ctrl.getDisplayLine(true))) && !lastParkedCtrl.isInControlSuffix())\r\n      // QCR #970806\r\n      {\r\n        await this.handleInternalEventWithMgControlBase(lastParkedCtrl, InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n        if (this._stopExecution) {\r\n          if (ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.isTabControl()) {\r\n            ctrl.resetPrevVal();\r\n            await ctrl.RefreshDisplay();\r\n          }\r\n          // TODO: Focus & Tabbing: Handle Parking in this case. Should not return false in screen mode\r\n          return false;\r\n        }\r\n      } else\r\n        return false;\r\n    }\r\n    if (task.InCtrlPrefix)\r\n      return false;\r\n\r\n    task.InCtrlPrefix = true;\r\n\r\n    // make sure it has not come again through moveinrow.\r\n    // eg: if clicked ctrl on subform is non parkable, first time it executes RP CV for subforms and then\r\n    // enters moveinrow for parkable ctrl. we shouldnot execute this block when we come for CP of parkable ctrl.\r\n    // For tab, we come here directly for parkable ctrl, and this block must always execute if on diff forms.\r\n    // isSort : if clicked on table header, we park on colomn ctrl after sort, and we must include subforms\r\n    // in executing CVs\r\n\r\n    // TODO: Tabbing & Focusing: Check getLastMoveInRowDirection is relevant. While moving between controls by Tab code in if block was not called.\r\n    // But it was called on click to another control.\r\n    //if (task.getLastMoveInRowDirection() === Constants.MOVE_DIRECTION_NONE || this._isSorting) {\r\n\r\n    // If the current ctrl is on a subform, then execute in sequence\r\n    // 1. RS of nested subforms until subform task containg these 2 subforms. we must also execute RS if clicked\r\n    //    in subform and parked back on a ctrl's task. (#722115- currClickedCtrl and ctrl should not be on different window)\r\n    // 2. CV execution of LastParkedCtrl till end\r\n    // 3. RP-CVs for all intermediate subforms\r\n    let prevCtrl: MgControl = lastParkedCtrl;\r\n    if (currClickedCtrl !== null && (<Task>currClickedCtrl.getForm().getTask()).getMgdID() === (<Task>ctrl.getForm().getTask()).getMgdID() && ctrl.onDiffForm(currClickedCtrl))\r\n      prevCtrl = currClickedCtrl;\r\n\r\n    if (prevCtrl !== null && ctrl.onDiffForm(prevCtrl)) {\r\n      // RS of nested subforms until subform task contaning these 2 subforms\r\n      let prevTask: Task = <Task>prevCtrl.getForm().getTask();\r\n      await prevTask.execSubformRecSuffix(<Task>ctrl.getForm().getTask());\r\n      if (this._stopExecution) {\r\n        if (ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.isTabControl()) {\r\n          ctrl.resetPrevVal();\r\n          await ctrl.RefreshDisplay();\r\n        }\r\n        task.InCtrlPrefix = false;\r\n        return false;\r\n      }\r\n\r\n      if (ctrl.getForm().getTask().isAborting()) {\r\n        task.InCtrlPrefix = false;\r\n        return false;\r\n      }\r\n\r\n      await EventsManager.doSyncForSubformParent(task);\r\n    }\r\n\r\n    // Execute RP of the current task before executing the CVs before 'ctrl'\r\n    if (task.DataView.isEmptyDataview())\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n    else {\r\n      task.SubformExecMode = Task_SubformExecModeEnum.SET_FOCUS;\r\n      let rtEvt: RunTimeEvent = new RunTimeEvent(ctrl, displayLine);\r\n      rtEvt.setInternal(InternalInterface.MG_ACT_REC_PREFIX);\r\n      await this.handleEvent(rtEvt, false);\r\n    }\r\n    if (this.GetStopExecutionFlag()) {\r\n      task.InCtrlPrefix = false;\r\n      return false;\r\n    }\r\n    //}\r\n\r\n    // QCR# 806015: If we have a single field with allow parking = Yes and Tab Into = No, then on pressing tab if cursor is not moved, we come to\r\n    // park on lastParkedCtrl(which is same as ctrl) since TabInto is not allowed.\r\n    // So to avaoid infinite recursion, we should not again try to park on it.\r\n    if (!await ctrl.IsParkable() && ctrl !== lastParkedCtrl) {\r\n      task.InCtrlPrefix = false;\r\n\r\n      if (lastParkedCtrl === null || !await lastParkedCtrl.invoke())\r\n        await this.HandleNonParkableControls(ctrl.getForm().getTask());\r\n\r\n      return false;\r\n    }\r\n\r\n    Logger.Instance.WriteSupportToLog(NString.Format('{0} Entering control: control {1}, row {2}', task.GetTaskDetails(), ctrl.Name, displayLine < 0 ? 0 : displayLine), true);\r\n\r\n    // if we have a stop execution ctrl, we need to use it as a srctrl, otherwise use\r\n    // the ctrl on which we executed last CS.\r\n\r\n\r\n    task.setLevel(Constants.TASK_LEVEL_CONTROL);\r\n    ctrl.KeyStrokeOn = false;\r\n    ctrl.ModifiedByUser = false;\r\n\r\n    task.setCurrField(ctrl.getField());\r\n\r\n    if (ctrl.IsRepeatable)\r\n      await form.bringRecordToPage();\r\n\r\n    // enable-disable actions for Subforms\r\n    if (lastParkedCtrl !== ctrl) {\r\n      if ((lastParkedCtrl === null && ctrl.getForm().isSubForm()) || (lastParkedCtrl !== null && (ctrl.getForm().isSubForm() || lastParkedCtrl.getForm().isSubForm()))) {\r\n        let lastParkedTask: Task = null;\r\n        if (lastParkedCtrl !== null)\r\n          lastParkedTask = <Task>lastParkedCtrl.getForm().getTask();\r\n\r\n        if (lastParkedTask !== task) {\r\n          let firstTime: boolean = true;\r\n          let isSonSubform: boolean;\r\n          let parentTask: Task;\r\n\r\n          if (lastParkedTask !== null) {\r\n            isSonSubform = lastParkedTask.IsSubForm;\r\n\r\n            for (parentTask = lastParkedTask; parentTask !== null && isSonSubform; parentTask = <Task>parentTask.getParent()) {\r\n              if (!firstTime) {\r\n                isSonSubform = parentTask.IsSubForm;\r\n                parentTask.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, false);\r\n                parentTask.ActionManager.enable(InternalInterface.MG_ACT_DELLINE, false);\r\n                parentTask.enableCreateActs(false);\r\n              } else\r\n                firstTime = false;\r\n            }\r\n          }\r\n\r\n          isSonSubform = task.IsSubForm;\r\n\r\n          for (parentTask = <Task>task.getParent(); (parentTask !== null) && isSonSubform; parentTask = <Task>parentTask.getParent()) {\r\n            isSonSubform = parentTask.IsSubForm;\r\n            if (parentTask.getEnableZoomHandler())\r\n              parentTask.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);\r\n            await parentTask.setCreateDeleteActsEnableState();\r\n          }\r\n\r\n          // Whenever we are moving between tasks, re-evaluate AllowModes.\r\n          await task.enableModes();\r\n        }\r\n      }\r\n    }\r\n\r\n    // enable actions and states\r\n    if (task.getEnableZoomHandler() || ctrl.useZoomHandler())\r\n      task.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);\r\n\r\n    if (ctrl.isTextControl() || ctrl.isChoiceControl())\r\n      ctrl.SetKeyboardLanguage();\r\n\r\n    if (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON)\r\n      task.ActionManager.enable(InternalInterface.MG_ACT_BUTTON, true);\r\n    await task.setCreateDeleteActsEnableState();\r\n\r\n    let field: Field = <Field>ctrl.getField();\r\n    if (field !== null && field.NullAllowed && ctrl.isModifiable() && ctrl.Type !== MgControlType.CTRL_TYPE_BUTTON)\r\n      task.ActionManager.enable(InternalInterface.MG_ACT_RT_EDT_NULL, true);\r\n\r\n    return true;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   do some default operations for an event and return true to tell the caller\r\n  ///   to continue handling the event\r\n  /// </summary>\r\n  /// <param name = \"evt\">the event to handle</param>\r\n  /// <returns> tells the caller whether to continue handling the event</returns>\r\n  private async commonHandlerBefore(evt: RunTimeEvent): Promise<boolean> {\r\n    let evtSave: RunTimeEvent = evt;\r\n    let task: Task = <Task>evt.getTask();\r\n    let rec: Record = null;\r\n    let prevRec: Record = null;\r\n    let val: string;\r\n    let oldDisplayLine: number = Int32.MinValue;\r\n\r\n    if (this._stopExecution)\r\n      return false;\r\n\r\n    if (task.isAborting())\r\n      return false;\r\n\r\n    if (evt.getType() === ConstInterface.EVENT_TYPE_SYSTEM) {\r\n      let actId: number = this.getMatchingAction(evt.getKbdItm());\r\n      if (actId !== 0 && evt.Control !== null)\r\n      // && actId != MG_ACT_SELECT)\r\n      {\r\n        evt = new RunTimeEvent(evt, evt);\r\n        evt.setInternal(actId);\r\n        evt.setArgList(null);\r\n        let mgControl: MgControl = <MgControl>evt.Control;\r\n        evtSave.setCtrl(mgControl);\r\n        if (mgControl === null)\r\n          return false;\r\n      }\r\n    }\r\n\r\n    // QCR# 939253 - we have to process commonHandlerBefore even for internal event converted\r\n    // from system Event\r\n    if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {\r\n      let form: MgForm = <MgForm>task.getForm();\r\n      let displayLine: number = evt.getDisplayLine();\r\n      let dv: DataView = <DataView>task.DataView;\r\n      rec = dv.getCurrRec();\r\n\r\n      let ctrl: MgControl = <MgControl>evt.Control;\r\n      let intEvtCode: number = evt.getInternalCode();\r\n\r\n      let lastFocusedCtrl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n\r\n      // for internal events\r\n      switch (intEvtCode) {\r\n        case InternalInterface.MG_ACT_ZOOM:\r\n          let boolval = await this.selectProg(ctrl);\r\n          if (boolval)\r\n            return false;\r\n        case InternalInterface.MG_ACT_WEB_ON_DBLICK:\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_FOCUS:\r\n          await this.handleFocus(ctrl, displayLine, evt.isProduceClick());\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_FOCUS_ON_NON_MAGIC_CONTROL:\r\n          await this.handleFocusOnNonMagicControl(ctrl);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_KEYDOWN:\r\n          await this.handleKeyDown(task, ctrl, evt);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_MOUSEUP:\r\n          await this.handleMouseUp(ctrl, displayLine, evt.isProduceClick());\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_SELECTION:\r\n          await this.onActSelection(ctrl, form, evt);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_TIMER:\r\n          await this.handleTimer(evt);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_RESIZE:\r\n          this.handleResize(ctrl, displayLine);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_ROW_DATA_CURR_PAGE:\r\n          await this.handleRowDataCurPage(ctrl, displayLine, evt.isSendAll(), evt.LastFocusedVal);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_DV_TO_GUI:\r\n          await this.handleTransferDataToGui(ctrl);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER:\r\n          await this.fetchRecordsAheadFromServer(ctrl);\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_ENABLE_EVENTS:\r\n          this.handleEnableEvents(evt, true);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_DISABLE_EVENTS:\r\n          this.handleEnableEvents(evt, false);\r\n          return false;\r\n\r\n        case InternalInterface.MG_ACT_TASK_PREFIX:\r\n          task.setLevel(Constants.TASK_LEVEL_TASK);\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_TASK_SUFFIX:\r\n          task.setLevel(Constants.TASK_LEVEL_TASK);\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_REC_PREFIX:\r\n          // Defect 115903. Do not execute RP if the subform parent task didn't finished yet\r\n          // it's CommonHandlerBefore for RP.\r\n          if (task.IsSubForm && (<Task>task.getParent()).InCommonHandlerBeforeRP)\r\n            return false;\r\n\r\n          // Recovery from transaction restart was completed. We may now clear the flag\r\n          task.setAfterRetry(ConstInterface.RECOVERY_NONE);\r\n          task.DataSynced = false;\r\n\r\n          if (!task.isStarted())\r\n            return false;\r\n\r\n\r\n          // if the form contains a table and the control was in the table\r\n          // move to the new row\r\n          if (form.getRowsInPage() > Int32.MinValue && displayLine > Int32.MinValue) {\r\n            // ensure a valid row\r\n            while (!dv.recExists(displayLine) && displayLine > 0) {\r\n              displayLine--;\r\n            }\r\n            if (displayLine >= 0) {\r\n              prevRec = dv.getCurrRec();\r\n              let oldTaskMode: string = task.getMode();\r\n              let oldRecId: number = prevRec.getId();\r\n\r\n              try {\r\n                oldDisplayLine = form.DisplayLine;\r\n                // oldDisplayLine = form.getCurrRow()\r\n                form.PrevDisplayLine = oldDisplayLine;\r\n                await form.setCurrRowByDisplayLine(displayLine, true, false);\r\n                // refresh the display if the previous record was deleted or canceled\r\n                if (prevRec != null && !dv.recExistsById(prevRec.getId())) {\r\n                  await form.RefreshDisplay(Constants.TASK_REFRESH_TABLE);\r\n                  // The following refresh is essential. If it fails because of an\r\n                  // exception then the old curr row is restored (in the catch\r\n                  // statement). It can happen when the user clicks on a line which\r\n                  // becomes blank due to the deletion of the previous record.\r\n                  await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n                }\r\n                rec = dv.getCurrRec();\r\n              } catch (e) {\r\n                if (e instanceof RecordOutOfDataViewException) {\r\n                  if (this._stopExecution) {\r\n                    if (oldTaskMode === Constants.TASK_MODE_CREATE && oldDisplayLine > 0 &&\r\n                      !dv.recExistsById(oldRecId)) {\r\n                      let prevLine: number = form.getPrevLine(oldDisplayLine);\r\n                      await form.restoreOldDisplayLine(prevLine);\r\n                    } else\r\n                      await form.restoreOldDisplayLine(oldDisplayLine);\r\n                    await form.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n                    this.setStopExecution(false);\r\n                    lastFocusedCtrl = <MgControl>task.getLastParkedCtrl();\r\n                    task.getLastParkedCtrl();\r\n                    if (lastFocusedCtrl != null)\r\n                      await lastFocusedCtrl.invoke();\r\n                    this.setStopExecution(true);\r\n                    return false;\r\n                  } else\r\n                    Logger.Instance.WriteDevToLog(e.StackTrace);\r\n                } else throw e;\r\n              }\r\n            } else\r\n              throw new ApplicationException('in EventsManager.commonHandlerBefore(): invalid line number: ' +\r\n                displayLine);\r\n          }\r\n          if (rec == null)\r\n            throw new ApplicationException(\r\n              'in EventsManager.commonHandlerBefore(): no current record available !');\r\n\r\n          // only for non interactive tasks. Increase the task's counter for every record we pass.\r\n          // do it before the evalEndCond since it might include counter(0).\r\n          // increase only if going into the rec prefix.\r\n          if (!task.IsInteractive && task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n            task.increaseCounter();\r\n\r\n          // check the \"task end condition\" before entering the record\r\n          if (await task.evalEndCond(ConstInterface.END_COND_EVAL_BEFORE)) {\r\n            await task.endTask(true, false, false);\r\n            return false;\r\n          }\r\n          if (form.HasTable())\r\n            await form.bringRecordToPage();\r\n\r\n          // to prevent double prefix on the same record\r\n          if (task.getLevel() !== Constants.TASK_LEVEL_TASK)\r\n            return false;\r\n\r\n          await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n\r\n          Logger.Instance.WriteDevToLog('RECORD PREFIX: ' + task.queryTaskPath());\r\n          (dv.getCurrRec()).setForceSaveOrg(false);\r\n          (dv.getCurrRec()).Synced = false;\r\n\r\n          dv.saveOriginal();\r\n\r\n          // do Record Prefix for all fathers that their Record Prefix is not done earlier\r\n          if (task.IsSubForm && task.PerformParentRecordPrefix) {\r\n            let parentTask = task.getParent();\r\n            while (parentTask.IsSubForm) {\r\n              if (parentTask.getLevel() === Constants.TASK_LEVEL_TASK) {\r\n                await this.handleInternalEventWithTask(parentTask, InternalInterface.MG_ACT_REC_PREFIX);\r\n                parentTask = parentTask.getParent();\r\n                if (this.GetStopExecutionFlag())\r\n                  break;\r\n              } else\r\n                break;\r\n            }\r\n          }\r\n\r\n          // handle sub-forms\r\n          task.InCommonHandlerBeforeRP = true;\r\n          if (await task.CheckRefreshSubTasks())\r\n            await dv.computeSubForms();\r\n          task.InCommonHandlerBeforeRP = false;\r\n          task.setLevel(Constants.TASK_LEVEL_RECORD);\r\n          // enable-disable actions for a record\r\n          await task.enableRecordActions();\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_REC_SUFFIX:\r\n          // Force record suffix:\r\n          let forceSuffix: boolean = false;\r\n          let isSelectionTable: boolean;\r\n\r\n          task.ConfirmUpdateNo = false;\r\n\r\n          // No record -> no suffix\r\n          if (rec == null)\r\n            return false;\r\n\r\n          forceSuffix = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);\r\n\r\n          // do not execute the \"before record suffix\" when deleting the record and\r\n          // the task mode is delete (the second round)\r\n          if ((rec.Modified || forceSuffix) && rec.getMode() === DataModificationTypes.Delete &&\r\n            task.getMode() === Constants.TASK_MODE_DELETE)\r\n            return true;\r\n\r\n          // to prevent double suffix on the same record\r\n          if (task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n            return false;\r\n\r\n          if (task.getLevel() === Constants.TASK_LEVEL_CONTROL) {\r\n            task.setInRecordSuffix(true);\r\n            await this.handleInternalEventWithMgControlBase(task.getLastParkedCtrl(), InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n            task.setInRecordSuffix(false);\r\n            if (this._stopExecution)\r\n              return false;\r\n          }\r\n\r\n          await task.handleEventOnSlaveTasks(InternalInterface.MG_ACT_REC_SUFFIX);\r\n          if (this._stopExecution)\r\n            return false;\r\n          Logger.Instance.WriteDevToLog('RECORD SUFFIX: ' + task.queryTaskPath());\r\n\r\n\r\n          // indicate next verifyCtrl is the first ctrl in the record\r\n\r\n          task.setLevel(Constants.TASK_LEVEL_TASK);\r\n\r\n          isSelectionTable = await task.checkProp(PropInterface.PROP_TYPE_SELECTION, false);\r\n\r\n          // Query mode -> do suffix only if we force it or somehow the record was updated\r\n          if (task.getMode() === Constants.TASK_MODE_QUERY && !forceSuffix && !rec.Modified &&\r\n            !isSelectionTable)\r\n            return false;\r\n\r\n          if (!rec.Modified && !forceSuffix && (!isSelectionTable || !task.InSelect)) {\r\n            if (rec.getMode() === DataModificationTypes.Delete) {\r\n              return await this.executeControlVerification(task);\r\n            }\r\n            return false;\r\n          }\r\n\r\n          if (task.getMode() !== Constants.TASK_MODE_DELETE && rec.Modified) {\r\n            if (!await this.updateConfirmed(task))\r\n              return false;\r\n          }\r\n\r\n          let stopExecution: boolean = !await this.executeControlVerification(task);\r\n          // do not continue processing RS if CV returns error\r\n          if (stopExecution)\r\n            return false;\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_PREFIX:\r\n          if (await this.handleCtrlPrefix(evt))\r\n            return true;\r\n          else {\r\n            // did not succeed in entering the ctrl\r\n            evt.Control.InControl = false;\r\n            return false;\r\n          }\r\n\r\n        case InternalInterface.MG_ACT_CANCEL:\r\n          Manager.CleanMessagePane(task); // QCR #371321\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_SUFFIX:\r\n\r\n          // if we have a stopexecution ctrl we should not execute CS.\r\n          if (ctrl == null || this.getStopExecutionCtrl() != null)\r\n            return false;\r\n\r\n          // to prevent double suffix on the same control\r\n          if (task.getLevel() !== Constants.TASK_LEVEL_CONTROL)\r\n            return false;\r\n\r\n          if (!ctrl.isSubform()) {\r\n            val = Manager.GetCtrlVal(ctrl);\r\n\r\n            // We are resetting the flag as we are moving from one control to other control.\r\n            task.CurrentEditingControl = null;\r\n\r\n            // validate the controls value\r\n            // Fixed bug #:758788, the browser control will not be update from the filed.\r\n            // Patch for QCR #729706:\r\n            // Magic thread puts the following GUI commands:\r\n            //    PROP_SET_IMAGE_FILE_NAME to set the image on the Image control.\r\n            //    PROP_SET_TEXT to set the text of the TextBox control.\r\n            //    SET_FOCUS to focus on the TextBox control.\r\n            // Now, when the execution is by F7, if the file is not retrieved from the server\r\n            // (i.e. if there is 404 error), HttpClient re-tries to get the file for HTTPtimeout.\r\n            // During this time all the GUI events in GuiCommandsQueue remains pending unhandled.\r\n            // In the mean time, Magic thread executes the Exit event and during this, it tries\r\n            // to execute the Ctrl Suffix of the TextBox control.\r\n            // Since SET_FOCUS is still pending in the queue, the logical control (if allowTesting=No)\r\n            // is not mapped with any actual windows control.\r\n            // Now when we try to get the value of this logical control, LogicalControl.getEditorControl()\r\n            // returns null and so, StaticText.getValue() returns LogicalControl.Text instead of Control.Text\r\n            // Because PROP_SET_TEXT is also pending, LogicalControl.Text is null.\r\n            // And so there is an exception when using it.\r\n            // If AllowTesting=Yes, the val will be a blank string. So, there is no crash.\r\n            // But here we have another problem. Suppose, the field had an Init expression.\r\n            // Now, MgControl's value would be the inited value and the val is a blank string.\r\n            // So, we will have variable change.\r\n            // Since the problem is related to a very specific scenario -- when the image control was\r\n            // the first dropped control on the form, image cannot be accessed at the time of task\r\n            // loading and task needs to be closed, we are putting a patch here by checking val for NULL.\r\n            // The ideal solution would be --- instead of sending the image file name from Magic thread\r\n            // to Gui thread and loading the image from the Gui thread, we can load the image from the\r\n            // Magic thread (using sync execution i.e. via GuiInteractive) and send it to the Gui thread.\r\n            if (!task.cancelWasRaised() &&\r\n              (ctrl.Type !== MgControlType.CTRL_TYPE_BROWSER && (!isNullOrUndefined(ctrl._field) && (ctrl._field.getType() === StorageAttribute.DATE || ctrl._field.getType() == StorageAttribute.NUMERIC) || val !== null) && typeof val != 'undefined' &&\r\n                !await ctrl.validateAndSetValue(val, true))) {\r\n              this.setStopExecution(true);\r\n              return false;\r\n            }\r\n          }\r\n\r\n          // when stop execution in on, don't clear the msg from status.\r\n          if (!this._stopExecution)\r\n            Manager.CleanMessagePane(task);\r\n\r\n          // reset InControl before executing control verification\r\n          ctrl.InControl = false;\r\n          ctrl.ClipBoardDataExists = false;\r\n          ctrl.ValidateControl = true;\r\n          ctrl.setInControlSuffix(true);\r\n          break;\r\n\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  /// execute a select program and returns true if the program was executed  </summary>\r\n  /// <param name=\"ctrl\">the source control</param>\r\n  /// <param name=\"prompt\">if true then the caller is executing the called program at the end of control prefix</param>\r\n  /// <returns></returns>\r\n  protected async selectProg(ctrl: MgControl): Promise<boolean> {\r\n    let cmd: IClientCommand;\r\n    let value: String;\r\n    let mgVal: string;\r\n    let progExecuted = false;\r\n    let task = <Task>ctrl.getForm().getTask();\r\n\r\n    // check if there is select program to the control\r\n    if (ctrl.HasSelectProgram()) {\r\n      //check if the control is parkable\r\n      if (ctrl.IsParkable()) {\r\n\r\n        value = Manager.GetCtrlVal(ctrl);\r\n\r\n        // validate the controls value\r\n        if (!ctrl.validateAndSetValue(value, false))\r\n          this.setStopExecution(true);\r\n        else {\r\n          let encodedVal: string = null;\r\n          mgVal = await ctrl.getMgValue(value);\r\n          var rec = (<DataView>task.DataView).getCurrRec();\r\n          encodedVal = rec.getXMLForValue(ctrl.getField().getId(), mgVal);\r\n          cmd = CommandFactory.CreateSelectProgramCommand(task.getTaskTag(), null, Int32.MinValue, ctrl.getDitIdx(), encodedVal);\r\n          task.getMGData().CmdsToServer.Add(cmd);\r\n\r\n          let commandsProcessorServer: CommandsProcessorBase = CommandsProcessorManager.GetCommandsProcessor();\r\n          await commandsProcessorServer.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n\r\n          progExecuted = true;\r\n        }\r\n      }\r\n    }\r\n    return progExecuted;\r\n  }\r\n\r\n  private async executeControlVerification(task: Task): Promise<boolean> {\r\n\r\n    // check all handlers if it is control verification. Execute all SV handlers\r\n    let table: HandlersTable = task.getHandlersTab();\r\n    for (let i: number = 0; i < table.getSize(); i++) {\r\n      let handler: EventHandler = table.getHandler(i);\r\n      let evt: Event = handler.getEvent();\r\n      if (evt.getInternalCode() === InternalInterface.MG_ACT_CTRL_VERIFICATION) {\r\n        let control: MgControl = ((task.getForm() !== null) ? (<MgForm>task.getForm()).getCtrlByCtrlName(handler.getCtrlName()) : null);\r\n        if (!isNullOrUndefined(control)) {\r\n          let runTimeEvent: RunTimeEvent = new RunTimeEvent(control);\r\n          runTimeEvent.setInternal(InternalInterface.MG_ACT_CTRL_VERIFICATION);\r\n          await this.handleEvent(runTimeEvent, false);\r\n          if (this._stopExecution) {\r\n            // if there is error, park/focus on this control where error occurs in CV execution.\r\n            LastFocusedManager.setLastFocusedControl(task, control);\r\n            this.setStopExecutionCtrl(null);\r\n            this.setStopExecutionCtrl(control);\r\n            return false;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n\r\n  private async onActSelection(ctrl: MgControl, form: MgForm, evt: RunTimeEvent): Promise<void> {\r\n    let displayLine: number = evt.getDisplayLine();\r\n    if (displayLine === Int32.MinValue)\r\n      displayLine = form.DisplayLine;\r\n\r\n    let simulate: boolean = ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_LIST || ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_BUTTON || (ctrl.Type === MgControlType.CTRL_TYPE_TAB && !evt.isProduceClick());\r\n    if (simulate)\r\n      await this.simulateSelection(ctrl, evt.getValue(), displayLine, evt.isProduceClick());\r\n    else\r\n      await this.handleSelection(ctrl, displayLine, evt.getValue());\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Handle the MG_ACT_SUBFORM_CLOSE\r\n  /// </summary>\r\n  /// <param name = \"form\">\r\n  /// </param>\r\n  /// <param name = \"evt\">\r\n  /// </param>\r\n  private async onSubformClose(task: Task, evt: RunTimeEvent): Promise<void> {\r\n\r\n    if ((evt.getArgList() != null) && (evt.getArgList().getSize() === 1)) {\r\n      let subformCtrl: MgControl = null;\r\n      let closingSubformName: string = await evt.getArgList().getArgValue(0, StorageAttribute.ALPHA, 0);\r\n\r\n      // QCR #283114. Argument of 'Subform refresh event' can be skipped or not exist.\r\n      if (closingSubformName == null)\r\n        return;\r\n\r\n      // RS must be executed only if the current subform is refreshed.\r\n      // If its brother is refreshed we do not need to execute RS of the current task.\r\n      for (let parentTask: Task = task; parentTask.getForm() != null && parentTask.getMgdID() === task.getMgdID(); parentTask = <Task>parentTask.getParent()) {\r\n        subformCtrl = <MgControl>parentTask.getForm().getCtrlByName(closingSubformName.trim(), MgControlType.CTRL_TYPE_SUBFORM);\r\n        if (subformCtrl != null) {\r\n          let subformTask: Task = <Task>subformCtrl.getSubformTask();\r\n          // If the subform task was not opened yet, but subform refresh is done,\r\n          // it's needed to open the subform. QCR #415914.\r\n          if (subformTask != null && !subformTask.IsRoute()) {\r\n            {\r\n              await this.performSubformClose(subformCtrl);\r\n            }\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   performSubformClose()   : Closes the subform task opened in the subformCtrl\r\n  /// </summary>\r\n  /// <param name = \"subformCtrl\">\r\n  /// </param>\r\n  public async performSubformClose(subformCtrl: MgControl): Promise<void> {\r\n    let subformTask: Task = <Task>subformCtrl.getSubformTask();\r\n    let parentTask: Task = <Task>subformCtrl.getForm().getTask();\r\n\r\n    let mgd: MGData = subformTask.getMGData();\r\n    this.pushNewExecStacks();\r\n    await subformTask.endTask(true, false, false, true);\r\n    this.popNewExecStacks();\r\n    if (!this._stopExecution) {\r\n      parentTask.TaskService.RemoveRecomputes(parentTask);\r\n      await subformTask.stop();\r\n\r\n      subformCtrl.resetSubformTask();\r\n      await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n      Commands.addClosesubform(CommandType.CLOSE_SUB_FORM, subformCtrl, subformTask.getTaskTag(), (<MgControlBase>subformCtrl).getName(), subformTask.getForm().buildFormName());\r\n\r\n      // Set mgd.abort(), in order to close current event loop of Modal subform.\r\n      // and reset it back to false once it comes out of current eventsloop().\r\n      if ((<MgControlBase>subformCtrl).IsModal())\r\n        mgd.abort();\r\n    }\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   calculate arguments for events\r\n  /// </summary>\r\n  /// <param name = \"evt\"> </param>\r\n  private createEventArguments(evt: RunTimeEvent): void {\r\n    if (evt.getArgList() === null) {\r\n      if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {\r\n        switch (evt.getInternalCode()) {\r\n          default:\r\n            break;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"doSuffix\"></param>\r\n  /// <returns></returns>\r\n  async DoTaskLevelRecordSuffix(task: TaskBase, refDoSuffix: RefParam<boolean>): Promise<boolean> {\r\n    let shouldReturn: boolean = false;\r\n    if (task.getLevel() === Constants.TASK_LEVEL_RECORD) {\r\n      refDoSuffix.value = false;\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n      if (this.GetStopExecutionFlag())\r\n        shouldReturn = true;\r\n    }\r\n\r\n    return shouldReturn;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"form\"></param>\r\n  async DoTaskLevelRecordPrefix(task: TaskBase): Promise<void> {\r\n    if (!this.GetStopExecutionFlag()) {\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   do the magic default operations according to the internal event code\r\n  /// </summary>\r\n  /// <param name = \"evt\">the event to handle </param>\r\n  /// <returns> tells the caller whether to continue handling the event </returns>\r\n  private async commonHandler(evt: RunTimeEvent): Promise<void> {\r\n    let task: Task = <Task>evt.getTask();\r\n    let mgData: MGData = task.getMGData();\r\n    let form: MgForm = <MgForm>task.getForm();\r\n    let ctrl: MgControl = <MgControl>evt.Control;\r\n    let lastParkedCtrl: MgControl;\r\n    let doSuffix: boolean = true;\r\n    let oldMode: string;\r\n    let server: CommandsProcessorBase = Task.CommandsProcessor;\r\n\r\n    if (this._stopExecution)\r\n      return;\r\n\r\n    // if this is a user event that converts to a system or internal even, convert it\r\n    if (evt.getType() === ConstInterface.EVENT_TYPE_USER)\r\n      evt = new RunTimeEvent(evt.getUserEvent(), evt);\r\n\r\n    try {\r\n      this.pushRtEvent(evt);\r\n\r\n      if (evt.getType() === ConstInterface.EVENT_TYPE_SYSTEM) {\r\n        let actId: number = this.getMatchingAction(evt.getKbdItm());\r\n        if (actId !== 0)\r\n        // handled internally\r\n        {\r\n          evt = new RunTimeEvent(evt, evt);\r\n          evt.setInternal(actId);\r\n          evt.setArgList(null);\r\n        }\r\n      }// end of system events processing\r\n\r\n      // execute the common handling of internal events only if they are not immediate.\r\n      // an event is immediate when it was raised by a raise event operation that its\r\n      // wait condition is yes or evaluates to true.\r\n      let cmd: IClientCommand;\r\n      if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && !evt.isImmediate() && this.ActAllowed(evt.getInternalCode()) && !this._processingTopMostEndTask) {\r\n        let cmdsToServer: CommandsTable = <CommandsTable>mgData.CmdsToServer;\r\n        let dv: DataView = <DataView>task.DataView;\r\n        let rec: Record = dv.getCurrRec();\r\n\r\n        let intEvtCode: number = evt.getInternalCode();\r\n\r\n        // for internal events\r\n        switch (intEvtCode) {\r\n\r\n          case InternalInterface.MG_ACT_SUBFORM_CLOSE:\r\n            await this.onSubformClose(task, evt);\r\n            break;\r\n\r\n\r\n          case InternalInterface.MG_ACT_BUTTON:\r\n          case InternalInterface.MG_ACT_CTRL_HIT:\r\n            // if button is not parkable, raise its event only if the action was not triggered by gui.\r\n            // direct click on the button will get here as ctrl hit , but is not triggered by gui (goes via selection event 1st)\r\n            // other ctrl_hit actions should consider the parkability\r\n            if (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON &&\r\n              (intEvtCode === InternalInterface.MG_ACT_BUTTON || !evt.isGuiTriggeredEvent() || ctrl.isParkable(true))) {\r\n              let aRtEvt = new RunTimeEvent(ctrl);\r\n              if (ctrl.getRtEvtTask() != null)\r\n                aRtEvt.setTask(ctrl.getRtEvtTask());\r\n              if (ConstInterface.EVENT_TYPE_NONE !== aRtEvt.getType()) {\r\n                if (ctrl.useZoomHandler()) {\r\n                  let taskToEnable: Task = <Task>aRtEvt.getTask();\r\n                  if (taskToEnable != null)\r\n                    taskToEnable.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);\r\n                }\r\n                aRtEvt.setArgList(ctrl.ArgList);\r\n                await aRtEvt.setPublicName();\r\n                this.addToTail(aRtEvt);\r\n                this.checkAndSaveRouteEventIfCtxRemovedFromSrvr(aRtEvt);\r\n              }\r\n            } else if (ctrl.Type === MgControlType.CTRL_TYPE_TAB) {\r\n              // Fixed bug #724150: as we doing for online for tab control we send ACT_ZOOM (Choiceinp.cpp ::DitGet())\r\n              this.addInternalEventWithCtrlAndCode(ctrl, InternalInterface.MG_ACT_ZOOM);\r\n            } else if (ctrl.Type === MgControlType.CTRL_TYPE_RADIO) {\r\n              ctrl.setControlToFocus();\r\n            }\r\n\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TOGGLE_INSERT:\r\n            RuntimeContextBase.Instance.ToggleInsertMode();\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CLOSE:\r\n            let rtEvt = new RunTimeEvent(evt, evt);\r\n            rtEvt.setInternal(InternalInterface.MG_ACT_EXIT);\r\n            this.addToTail(rtEvt);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_EXIT:\r\n            // if 'exit' accepted on MDI, exit the top most task. same as when exiting the system.\r\n            let taskToEnd: Task = (task.isMainProg() ? MGDataCollection.Instance.StartupMgData.getFirstTask() : task);\r\n            await taskToEnd.endTask(evt.reversibleExit(), false, evt.ExitDueToError());\r\n\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_EXIT_SYSTEM:\r\n            // end the top most task with form.\r\n            await MGDataCollection.Instance.StartupMgData.getFirstTask().endTask(evt.reversibleExit(), false,\r\n              false);\r\n            // GetTopMostTaskWithForm(task).endTask(evt.reversibleExit(), false, false);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_NXTLINE:\r\n            if (form != null)\r\n              await form.moveInView(Constants.MOVE_UNIT_ROW, Constants.MOVE_DIRECTION_NEXT);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_PRVLINE:\r\n            if (form != null)\r\n              await form.moveInView(Constants.MOVE_UNIT_ROW, Constants.MOVE_DIRECTION_PREV);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_NXTPAGE:\r\n            if (form != null)\r\n              await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_NEXT);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_PRVPAGE:\r\n            if (form != null)\r\n              await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_PREV);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_BEGPAGE:\r\n            if (form != null)\r\n              await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_BEGIN);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_ENDPAGE:\r\n            if (form != null)\r\n              await form.moveInView(Constants.MOVE_UNIT_PAGE, Constants.MOVE_DIRECTION_END);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_BEGTBL:\r\n            // #918588: If ctrl+home/ctrl+end pressed when parked on listbox\r\n            // then Begin table event should not be handled.\r\n            lastParkedCtrl = <MgControl>task.getLastParkedCtrl();\r\n            if (lastParkedCtrl == null || !lastParkedCtrl.isListBox()) {\r\n              if (form != null)\r\n                await form.moveInView(Constants.MOVE_UNIT_TABLE, Constants.MOVE_DIRECTION_BEGIN);\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TBL_ENDTBL:\r\n            // #918588: If ctrl+home/ctrl+end pressed when parked on listbox\r\n            // then Begin table event should not be handled.\r\n            lastParkedCtrl = <MgControl>task.getLastParkedCtrl();\r\n            if (lastParkedCtrl === null || !lastParkedCtrl.isListBox()) {\r\n              if (form != null)\r\n                await form.moveInView(Constants.MOVE_UNIT_TABLE, Constants.MOVE_DIRECTION_END);\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_WEB_ON_DBLICK: {\r\n            // Unlike Online, here SELECT or ZOOM comes after the DBCLICK.\r\n            // If there is a DBCLICK handler with propogate = 'NO' , these actions will not be raised.\r\n            let ctrlType: MgControlType = ctrl.Type;\r\n            let putAction: number = InternalInterface.MG_ACT_NONE;\r\n            if (ctrlType !== MgControlType.CTRL_TYPE_TABLE && ctrlType !== MgControlType.CTRL_TYPE_LABEL &&\r\n              ctrlType !== MgControlType.CTRL_TYPE_IMAGE) {\r\n              if (ctrl.getForm().getTask().ActionManager.isEnabled(InternalInterface.MG_ACT_SELECT))\r\n                putAction = InternalInterface.MG_ACT_SELECT;\r\n              else {\r\n                if (ctrl.getForm().getTask().ActionManager.isEnabled(InternalInterface.MG_ACT_ZOOM))\r\n                  putAction = InternalInterface.MG_ACT_ZOOM;\r\n              }\r\n\r\n              if (putAction !== InternalInterface.MG_ACT_NONE)\r\n                this.addInternalEventWithCtrlAndCode(ctrl, putAction);\r\n            }\r\n          }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_DELLINE:\r\n            if (await this.HandleActionDelline(task, dv, rec, false))\r\n              return;\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CRELINE:\r\n          case InternalInterface.MG_ACT_CRELINE_ABOVE:\r\n            if (task.DataView.isEmptyDataview()) {\r\n              await this.gotoCreateMode(task);\r\n\r\n              break;\r\n            }\r\n            if (task.getInCreateLine())\r\n              break;\r\n\r\n            task.setInCreateLine(true);\r\n\r\n            try {\r\n              if (task.getLevel() === Constants.TASK_LEVEL_CONTROL) {\r\n                await this.handleInternalEventWithMgControlBase(task.getLastParkedCtrl(), InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n                if (this.GetStopExecutionFlag())\r\n                  return;\r\n              }\r\n\r\n              // verify that the current record is not already a new one\r\n              if (task.getMode() === Constants.TASK_MODE_CREATE && rec != null && !rec.Modified) {\r\n                if (await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false)) {\r\n                  doSuffix = false;\r\n                  await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n                  if (this.GetStopExecutionFlag() || task.isAborting())\r\n                    return;\r\n                } else {\r\n                  task.setLevel(Constants.TASK_LEVEL_TASK);\r\n                  await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n\r\n                  if (!this.GetStopExecutionFlag() && form != null) {\r\n                    // Defect 152355: Park on lastParkedControl if nextScreen event occurs if already in create mode and record not modified\r\n                    let lastParkedControl: MgControl = <MgControl>task.getLastParkedCtrl();\r\n                    if (lastParkedControl !== null)\r\n                      await lastParkedControl.invoke();\r\n                  }\r\n                  return;\r\n                }\r\n              }\r\n              let refDoSuffix: RefParam<boolean> = new RefParam(doSuffix);\r\n              if (await this.DoTaskLevelRecordSuffix(task, refDoSuffix))\r\n                return;\r\n              doSuffix = refDoSuffix.value;\r\n\r\n              if (form != null) {\r\n\r\n                if ((task.getMode() !== Constants.TASK_MODE_CREATE) || !task.ConfirmUpdateNo)\r\n                  await form.addRec(doSuffix, intEvtCode == InternalInterface.MG_ACT_CRELINE_ABOVE ? true : false);\r\n              }\r\n\r\n              await this.DoTaskLevelRecordPrefix(task);\r\n              await this.HandleActEnterRowEditing(task);\r\n\r\n            } finally {\r\n              task.setInCreateLine(false);\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CANCEL:\r\n            await this.HandleActCancel(evt, task, form, ctrl, rec, true);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_ENTER_ROW_EDITING:\r\n            await this.HandleActEnterRowEditing(task);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_RT_QUIT:\r\n            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_RT_QUIT);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_RTO_CREATE:\r\n            if (task.getMode() === Constants.TASK_MODE_CREATE ||\r\n              await (task.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean()) {\r\n              await this.gotoCreateMode(task);\r\n\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_RTO_QUERY:\r\n            if (task.getMode() !== Constants.TASK_MODE_QUERY &&\r\n              (await (task.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean()) === false)\r\n              break;\r\n            await task.enableModes();\r\n            oldMode = task.getOriginalTaskMode();\r\n            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n            if (!this.GetStopExecutionFlag()) {\r\n              task.setMode(Constants.TASK_MODE_QUERY);\r\n              if (oldMode !== Constants.TASK_MODE_CREATE) {\r\n                await dv.currRecCompute(true);\r\n                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n                if (ctrl != null)\r\n                  await ctrl.invoke();\r\n                await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n              } else {\r\n                // we already executed record suffix - so we need to prevent the view refresh\r\n                // from executing it again\r\n                task.setPreventRecordSuffix(true);\r\n                task.setPreventControlChange(true);\r\n                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_RT_REFRESH_VIEW);\r\n                if (ctrl != null)\r\n                  await ctrl.invoke();\r\n                task.setPreventRecordSuffix(false);\r\n                task.setPreventControlChange(false);\r\n                if (!dv.isEmpty() && (dv.getCurrRec()).getMode() !== DataModificationTypes.Insert)\r\n                  task.setMode(Constants.TASK_MODE_QUERY);\r\n                else\r\n                  task.setMode(Constants.TASK_MODE_CREATE);\r\n                await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n              }\r\n              task.setOriginalTaskMode(Constants.TASK_MODE_QUERY);\r\n              await task.setCreateDeleteActsEnableState();\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_RTO_MODIFY:\r\n            if (task.getMode() !== Constants.TASK_MODE_MODIFY &&\r\n              (await (task.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean()) === false)\r\n              break;\r\n            await task.enableModes();\r\n            oldMode = task.getOriginalTaskMode();\r\n            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n            if (!this.GetStopExecutionFlag()) {\r\n              task.setMode(Constants.TASK_MODE_MODIFY);\r\n\r\n              if (oldMode !== Constants.TASK_MODE_CREATE) {\r\n                await dv.currRecCompute(true);\r\n                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n                if (ctrl != null)\r\n                  await ctrl.invoke();\r\n              } else {\r\n                // we already executed record suffix - so we need to prevent the view refresh\r\n                // from executing it again\r\n                task.setPreventRecordSuffix(true);\r\n                task.setPreventControlChange(true);\r\n                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_RT_REFRESH_VIEW);\r\n                if (ctrl != null)\r\n                  await ctrl.invoke();\r\n                task.setPreventRecordSuffix(false);\r\n                task.setPreventControlChange(false);\r\n                if (!dv.isEmpty() && (dv.getCurrRec()).getMode() !== DataModificationTypes.Insert)\r\n                  task.setMode(Constants.TASK_MODE_MODIFY);\r\n                else\r\n                  task.setMode(Constants.TASK_MODE_CREATE);\r\n                await form.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n              }\r\n              task.setOriginalTaskMode(Constants.TASK_MODE_MODIFY);\r\n              await task.setCreateDeleteActsEnableState();\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_SELECT:\r\n            /* preform rec suffix */\r\n            try {\r\n              task.InSelect = true;\r\n              await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n            } finally {\r\n              task.InSelect = false;\r\n            }\r\n            if (!this._stopExecution) {\r\n              /* close the selection program */\r\n              await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_EXIT);\r\n            }\r\n            break;\r\n\r\n\r\n          case InternalInterface.MG_ACT_SUBFORM_REFRESH:\r\n            if ((evt.getArgList() != null) && (evt.getArgList().getSize() === 1)) {\r\n              let subformCtrl: MgControl = null;\r\n              let RefreshedSubformName: string = await evt.getArgList().getArgValue(0, StorageAttribute.ALPHA, 0);\r\n\r\n              // QCR #283114. Argument of 'Subform refresh event' can be skipped or not exist.\r\n              if (RefreshedSubformName == null)\r\n                break;\r\n\r\n              // RS must be executed only if the current subform is refreshed.\r\n              // If its brother is refreshed we do not need to execute RS of the current task.\r\n              for (let parentTask: Task = task; parentTask.getForm() != null && parentTask.getMgdID() === task.getMgdID(); parentTask = <Task>parentTask.getParent()) {\r\n                subformCtrl = <MgControl>parentTask.getForm().getCtrlByName(RefreshedSubformName.trim(), MgControlType.CTRL_TYPE_SUBFORM);\r\n                if (subformCtrl != null) {\r\n                  let subformTask: Task = <Task>subformCtrl.getSubformTask();\r\n                  // If the subform task was not opened yet, but subform refresh is done,\r\n                  // it's needed to open the subform. QCR #415914.\r\n                  if (subformTask == null) {\r\n                    // QCR #287562. Open the subform task only if the subform control is connected to the task.\r\n                    if (await (subformCtrl.getProp(PropInterface.PROP_TYPE_SUBFORM_TYPE)).getValueInt() !== SubformType.None)\r\n                      await this.OpenSubform(parentTask, subformCtrl);\r\n                  } else\r\n                    await parentTask.SubformRefresh(subformTask, true);\r\n                  break;\r\n                }\r\n              }\r\n            }\r\n            // if it is SubformRefresh that returned from the server, so search the task according to its task id (tag)\r\n            else if ((evt.getArgList() != null) && (evt.getArgList().getSize() === 2)) {\r\n              let subformTask: Task = task, parentTask;\r\n              let taskTag: string = await evt.getArgList().getArgValue(1, StorageAttribute.NUMERIC, 0);\r\n\r\n              while (subformTask.IsSubForm) {\r\n                parentTask = subformTask.getParent();\r\n                if (subformTask.getTaskTag() === taskTag) {\r\n                  await parentTask.SubformRefresh(subformTask, true);\r\n                  break;\r\n                }\r\n                subformTask = parentTask;\r\n              }\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_SUBFORM_OPEN:\r\n            await this.OpenSubform(task, <MgControl>evt.Control);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_RTO_SEARCH:\r\n            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n            if (!this.GetStopExecutionFlag()) {\r\n              cmd = CommandFactory.CreateEventCommand(task.getTaskTag(), intEvtCode);\r\n              task.getTaskCache().clearCache();\r\n              await task.DataviewManager.Execute(cmd);\r\n\r\n              // After view refresh, the server always returns curr rec as first rec.\r\n              if (!form.isScreenMode()) {\r\n                dv.setTopRecIdx(0);\r\n                if (form.HasTable()) {\r\n                  await form.restoreOldDisplayLine(form.recordIdx2DisplayLine(dv.getCurrRecIdx()));\r\n                }\r\n              }\r\n\r\n              await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n              if (ctrl != null)\r\n                await ctrl.invoke();\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_RT_REFRESH_SCREEN:\r\n          case InternalInterface.MG_ACT_RT_REFRESH_VIEW:\r\n          case InternalInterface.MG_ACT_RT_REFRESH_RECORD:\r\n            await this.handleRefreshEvents(evt);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_ACT_CLOSE_APPL:\r\n            cmd =\r\n              CommandFactory.CreateEventCommand(\r\n                MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag(),\r\n                InternalInterface.MG_ACT_BROWSER_ESC);\r\n            cmdsToServer.Add(cmd);\r\n            await server.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CONTEXT_REMOVE:\r\n\r\n            // check if transaction is pending\r\n            let currRecord = (<DataView>LastFocusedManager.Instance.getLastFocusedTask().DataView).getCurrRec();\r\n            if (ClientManager.TransCacheExists() || (currRecord != null && currRecord.Modified)) {\r\n              console.log('Pending transaction/record is modified, discarded \\'Context Remove\\' event.');\r\n            } else {\r\n              // Is there client context inactivity timeout?\r\n              if (Environment.Instance.getClientContextInactivityTimeout() > 0) {\r\n                await this.ExecuteClientContextInactivityTimer();\r\n              }\r\n\r\n              if (!EventsManager.clientContextInactivityTimerAborted) {\r\n\r\n                // add a command to terminate context at server side\r\n                let contextTerminationEventCommand: ContextTerminationEventCommand\r\n                  = CommandFactory.CreateContextTerminationEventCommand(MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag());\r\n                MGDataCollection.Instance.getCurrMGData().CmdsToServer.Add(<IClientCommand>contextTerminationEventCommand);\r\n\r\n                // response need not to be handled as the we are terminating the context\r\n                RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);\r\n\r\n                console.log('Removed context from server');\r\n                // set flag to that context is removed from server by 'Context Remove' event\r\n                RuntimeContextBase.Instance.RemovingContextFromServer = true;\r\n              } else {\r\n                console.log('Discarded \\'Context Remove\\' event as user event occurred.');\r\n                EventsManager.clientContextInactivityTimerAborted = false;\r\n                break;\r\n              }\r\n            }\r\n            break;\r\n          case InternalInterface.MG_ACT_SERVER_TERMINATION:\r\n          case InternalInterface.MG_ACT_DUMP_ENVIRONMENT:\r\n            cmd = CommandFactory.CreateEventCommand(task.getTaskTag(), intEvtCode);\r\n            cmdsToServer.Add(cmd);\r\n            await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_RT_EDT_NULL:\r\n            if (this._currField != null && this._currField.NullAllowed) {\r\n              // the next lines is an immitation of the behaviour of an online program:\r\n              // 1) the record must be updated in this event\r\n              // 2) a \"next field\" event is raised\r\n              await this._currField.setValueAndStartRecompute(this._currField.getMagicDefaultValue(), true, true, true, false);\r\n              await this._currField.updateDisplay();\r\n\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_ROLLBACK:\r\n            // for offline we need to cancel the edit and then go rollback the transaction, the same we doing for remove while return from the server\r\n            // see dataview.cs case ConstInterface.RECOVERY_ROLLBACK:\r\n            // for offline we will not get to ConstInterface.RECOVERY_ROLLBACK\r\n            await EventsManager.HandleRollbackAction(task, cmdsToServer, RollbackEventCommand_RollbackType.ROLLBACK);\r\n            break;\r\n\r\n\r\n          case InternalInterface.MG_ACT_OK:\r\n          case InternalInterface.MG_ACT_INDEX_CHANGE:\r\n          case InternalInterface.MG_ACT_COL_SORT:\r\n            // can sort only on column with an attached field.\r\n            // can change index only if the dataview is remote.\r\n            if ((intEvtCode === InternalInterface.MG_ACT_INDEX_CHANGE && task.DataviewManager.HasRemoteData) ||\r\n              (intEvtCode === InternalInterface.MG_ACT_COL_SORT && ctrl.getField() != null)) {\r\n              // QCR #296325 & QCR #430288.\r\n              // Execute CS of the current control, because it can be a parameter for a subform.\r\n              // If it's value was changed, CS will refresh the subform before the sort.\r\n              let lastFocusedTask: Task = LastFocusedManager.Instance.getLastFocusedTask();\r\n              let focusedCtrl: MgControl = LastFocusedManager.getLastFocusedControl(LastFocusedManager.LastFocusMgdID);\r\n              if (focusedCtrl != null)\r\n                await this.handleInternalEventWithMgControlBase(focusedCtrl, InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n\r\n              if (!this.GetStopExecutionFlag())\r\n                await task.ExecuteNestedRS(lastFocusedTask);\r\n\r\n              // QCR #438753. Execute RS of the sorted task.\r\n              if (!this.GetStopExecutionFlag() && task.getLevel() !== Constants.TASK_LEVEL_TASK)\r\n                await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n\r\n              if (!this.GetStopExecutionFlag()) {\r\n                task.getTaskCache().clearCache();\r\n\r\n                if (intEvtCode === InternalInterface.MG_ACT_INDEX_CHANGE) {\r\n                  let taskForm: MgForm = <MgForm>task.getForm();\r\n                  if (taskForm.HasTable())\r\n                    form.clearTableColumnSortMark(true);\r\n\r\n                  cmd = await CommandFactory.CreateIndexChangeCommand(task.getTaskTag(), (<DataView>task.DataView).GetCurrentRecId(), evt.getArgList());\r\n                } else {\r\n                  cmd = CommandFactory.CreateColumnSortCommand(task.getTaskTag(), evt.Direction, ctrl.getDitIdx(), ctrl.getField().getId(), (<DataView>task.DataView).GetCurrentRecId());\r\n                }\r\n\r\n                await task.DataviewManager.Execute(cmd);\r\n                dv.setTopRecIdx(0);\r\n                await form.restoreOldDisplayLine(0);\r\n\r\n                // QCR's #165815 & #291974. If the focused task and the sorted task is the same task or\r\n                // the focused task is a child of the sorted task, go to the first control in the first line.\r\n                // If the focused task is the parent task, do not leave the current control.\r\n                if (!(task === LastFocusedManager.Instance.getLastFocusedTask() || !task.pathContains(LastFocusedManager.Instance.getLastFocusedTask()))) {\r\n                  await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n                  if (!this.GetStopExecutionFlag() && !task.getPreventControlChange())\r\n                  // QCR #428697. Execute RS of all nested subforms.\r\n                    await lastFocusedTask.ExecuteNestedRS(task);\r\n                  if (!this.GetStopExecutionFlag() && focusedCtrl != null)\r\n                    await focusedCtrl.invoke();\r\n                } else\r\n                  await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n\r\n\r\n              }\r\n            }\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_COL_CLICK:\r\n            // can sort on column only if event is raised due to click action\r\n            // and a field is attached to column.\r\n\r\n            if (!this.GetStopExecutionFlag() && evt.isGuiTriggeredEvent() && ctrl.isColumnSortable()) {\r\n              let columnChildControl: MgControl = <MgControl>ctrl.getColumnChildControl();\r\n              if (columnChildControl != null) {\r\n                // handle Sort on Column\r\n                let aRtEvt = new RunTimeEvent(columnChildControl, evt.Direction, 0);\r\n                aRtEvt.setInternal(InternalInterface.MG_ACT_COL_SORT);\r\n                this.addToTail(aRtEvt);\r\n              }\r\n            }\r\n            break;\r\n\r\n        }\r\n      }\r\n      // end of internal events processing\r\n\r\n    } finally {\r\n      this.popRtEvent();\r\n    }\r\n  }\r\n\r\n  /*\r\n* HandleActEnterRowEditing\r\n* start the editing on row\r\n* */\r\n  private async HandleActEnterRowEditing(task: Task) {\r\n    if (task.getMode() === Constants.TASK_MODE_QUERY)\r\n      task.WriteToMessagePane(`Cannot enter Row Editing when in Query Mode.`);\r\n    else {\r\n      let myform: MgForm = <MgForm>task.getForm();\r\n      await myform.startRowEditing(myform.DisplayLine);\r\n    }\r\n  }\r\n\r\n  private async HandleStopRowEditing(task: Task) {\r\n    let myform: MgForm = <MgForm>task.getForm();\r\n    await myform.stopRowEditing(myform.DisplayLine);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Creates and executes subform open\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"subformControl\"></param>\r\n  private async OpenSubform(task: Task, subformControl: MgControl): Promise<void> {\r\n    task.TaskService.RemoveRecomputes(task);\r\n    let cmd: IClientCommand = CommandFactory.CreateSubformOpenCommand(task.getTaskTag(), subformControl.getDitIdx());\r\n    task.getMGData().CmdsToServer.Add(cmd);\r\n    await Task.CommandsProcessor.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"cmdsToServer\"></param>\r\n  /// <param name=\"rollbackType\"></param>\r\n  /// <returns></returns>\r\n  private static async HandleRollbackAction(task: Task, cmdsToServer: CommandsTable, rollbackType: RollbackEventCommand_RollbackType): Promise<void> {\r\n    let commandsProcessor: CommandsProcessorBase = Task.CommandsProcessor;\r\n    ClientRefreshCommand.ClientIsInRollbackCommand = true;\r\n    // for remote program : (with\\without local data) the rollback event in the server MUST\r\n    //                       be execute on the task that open the transaction\r\n    // for offline program the rollback transaction need to be execute on the task that open the transaction\r\n    task = task.TaskService.GetOwnerTransactionTask(task);\r\n\r\n    let cmd: IClientCommand = CommandFactory.CreateRollbackEventCommand(task.getTaskTag(), rollbackType);\r\n    cmdsToServer.Add(cmd);\r\n    await commandsProcessor.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n\r\n    ClientRefreshCommand.ClientIsInRollbackCommand = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"evt\"></param>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"form\"></param>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"rec\"></param>\r\n  /// <param name=\"lastParkedCtrl\"></param>\r\n  /// <param name=\"oldRecMode\"></param>\r\n  /// <param name=\"oldMode\"></param>\r\n  /// <returns></returns>\r\n  private async HandleActCancel(evt: RunTimeEvent, task: Task, form: MgForm, ctrl: MgControl, rec: Record, isMG_ACT_CANCEL: boolean): Promise<void> {\r\n    // Prevent recursive mode\r\n    // fixed bugs #:285498, 297455\\427703\\\r\n    if (task.InHandleActCancel)\r\n      return;\r\n\r\n    task.InHandleActCancel = true;\r\n\r\n    let oldMode: string = task.getMode();\r\n    let saveDisplayLine = task.getForm().DisplayLine;\r\n\r\n    // When do we show the 'Confirm Cancel window' ? when all the following conditions apply:\r\n    // 1. Task mode is not query\r\n    // 2. rec is not Updated. Updated is true when there was an Update operation with 'force update'. If it is true, then there is no meaning to show the\r\n    //    window since the update stays anyway (like in online when we go to CancelWasTriggered).\r\n    // 3. There must be a modification, otherwise there is nothing to cancel. So either Modified is true, meaning a field was moidfied , or\r\n    //    LastParkedCtrl().modifiedByUser(), meaning that we are in the middle of changing the field's value (The modified is false untill we exit the field).\r\n    // Create mode also goes here (rec removed and mode changes to modify) , but also will show the confirm cancel only if some change was done to the new record.\r\n    if (oldMode !== Constants.TASK_MODE_QUERY && !rec.Updated) {\r\n      if (isMG_ACT_CANCEL) {\r\n        if (rec.Modified || (task.getLastParkedCtrl() !== null && task.getLastParkedCtrl().ModifiedByUser)) {\r\n          if (await task.checkProp(PropInterface.PROP_TYPE_CONFIRM_CANCEL, false)) {\r\n            let confirmed = await GUIManager.Instance.confirm_bool(MsgInterface.CONFIRM_STR_CANCEL);\r\n            if (!confirmed) {\r\n              task.InHandleActCancel = false;\r\n              return;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      let oldRecMode: DataModificationTypes = rec.getMode();\r\n\r\n      // SpecialCancelOnCreate behavior for AllowEmptyDataView = Y : When there is single newly created record\r\n      // exist and user cancels it and task has AllowEmptyDataView=Y\r\n      // then change task mode to Modify mode so that server allows this task to enter again in EmptyDataView mode.\r\n      if (GuiEnvironment.Environment.GetSpecialCancelOnCreate() && task.getMode() == Constants.TASK_MODE_CREATE\r\n        && task.getOriginalTaskMode() == Constants.TASK_MODE_CREATE) {\r\n\r\n        let enable: boolean = await task.checkProp(PropInterface.PROP_TYPE_ALLOW_MODIFY, true);\r\n\r\n        if (enable) {\r\n          let allowEmptyDataView: boolean = await task.checkProp(PropInterface.PROP_TYPE_ALLOW_EMPTY_DATAVIEW, true);\r\n\r\n          if ((<DataView>task.DataView).getSize() == 1 && allowEmptyDataView) {\r\n            task.setMode('M');\r\n            task.DataView.setEmptyDataview(true);\r\n          }\r\n        }\r\n      }\r\n\r\n      if (isMG_ACT_CANCEL) {\r\n        // When canceling, we have to rollback the transaction.\r\n        // Unless the event does not allow to rollback in cancel. That can happen if the cancel was initiated by the server's's rollback.\r\n        if (task.isTransactionOnLevel(ConstInterface.TRANS_RECORD_PREFIX) && evt.RollbackInCancel()) {\r\n          await EventsManager.HandleRollbackAction(task, <CommandsTable>task.getMGData().CmdsToServer, RollbackEventCommand_RollbackType.CANCEL);\r\n        }\r\n      }\r\n\r\n      await EventsManager.HandleCancelEdit(evt, task, form, rec, oldRecMode);\r\n    }\r\n    // Qcr #747870 cancel should perform the record prefix if not quiting\r\n    else {\r\n      task.setLevel(Constants.TASK_LEVEL_TASK);\r\n\r\n      // we rollback a parent task while focused on subform/task. We do not want the ctrl on the subform to do ctrl suffix.\r\n      let lastFocusedControl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n      if (lastFocusedControl !== null) {\r\n        lastFocusedControl.getForm().getTask().setLevel(Constants.TASK_LEVEL_TASK);\r\n      }\r\n      if (!evt.isQuit()) {\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n        await this.HandleParkabilityOnRowChange(task);\r\n      }\r\n    }\r\n\r\n    // QCR# 941277: If Cancel event is called from Quit event, then don't execute Exit event\r\n    // if user has pressed 'No' on Confirm cancel box.\r\n    if (evt.isQuit())\r\n      await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_EXIT);\r\n\r\n    // reset isRowEditing\r\n    await form.stopRowEditing(saveDisplayLine);\r\n\r\n    task.InHandleActCancel = false;\r\n  }\r\n\r\n  /// <summary>\r\n  /// cancel the edit\r\n  /// </summary>\r\n  /// <param name=\"evt\"></param>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"form\"></param>\r\n  /// <param name=\"rec\"></param>\r\n  /// <param name=\"oldRecMode\"></param>\r\n  private static async HandleCancelEdit(evt: RunTimeEvent, task: Task, form: MgForm, rec: Record, oldRecMode: DataModificationTypes): Promise<void> {\r\n    // if the synced record (i.e. the record from the parent task of the subform) before Rollback was in 'Insert' mode,\r\n    // so it must be in 'Insert' more after return from the server\r\n    if (rec.Synced && oldRecMode === DataModificationTypes.Insert)\r\n      rec.setMode(oldRecMode);\r\n\r\n    if (form !== null) {\r\n      // reset the last parked control\r\n      if (task.getLastParkedCtrl() !== null)\r\n        task.getLastParkedCtrl().resetPrevVal();\r\n\r\n      await form.cancelEdit(true, evt.isQuit());\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"evt\"></param>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"dv\"></param>\r\n  /// <param name=\"rec\"></param>\r\n  /// <param name=\"nonInteractiveDelete\"></param>\r\n  /// <returns></returns>\r\n  private async HandleActionDelline(task: Task, dv: DataView, rec: Record, nonInteractiveDelete: boolean): Promise<boolean> {\r\n    let lastParkedCtrl: MgControl;\r\n    let myform: MgForm = <MgForm>task.getForm();\r\n    let saveIsRowEditing = myform.getIsRowEditingFromGui(myform.DisplayLine); //Commands.getIsRothis.handleInternalEventWithMgControlBase(lastParkedCtrl, InternalInterface.MG_ACT_CTRL_PREFIX);wEditing( task.getForm().getMainControl(), task.getForm().DisplayLine);    let oldRecMode: DataModificationTypes;\r\n    let oldRecMode: DataModificationTypes;\r\n    if (await task.checkProp(PropInterface.PROP_TYPE_ALLOW_DELETE, true)) {\r\n      lastParkedCtrl = <MgControl>task.getLastParkedCtrl();\r\n      if (lastParkedCtrl !== null)\r\n        await this.handleInternalEventWithMgControlBase(lastParkedCtrl, InternalInterface.MG_ACT_CTRL_SUFFIX);\r\n      if (!this.GetStopExecutionFlag()) {\r\n        oldRecMode = rec.getMode();\r\n\r\n        // Force the change to delete mode\r\n        rec.clearMode();\r\n        rec.setMode(DataModificationTypes.Delete);\r\n\r\n        if (oldRecMode === DataModificationTypes.Insert)\r\n          rec.setSendToServer(false);\r\n\r\n        // execute task suffix in Modify mode or when there is 'force record suffix'.\r\n        if (rec.Modified || await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false)) {\r\n          task.setMode(Constants.TASK_MODE_MODIFY);\r\n          await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n          // make sure that the record suffix completed successfully\r\n          if (this._stopExecution) {\r\n            if (!rec.SendToServer) {\r\n              await dv.addCurrToModified();\r\n              rec.setSendToServer(true);\r\n            }\r\n\r\n            rec.clearMode();\r\n            rec.setMode(oldRecMode);\r\n            this.setStopExecution(false);\r\n            await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n            this.setStopExecution(true);\r\n            return true;\r\n          }\r\n        }\r\n\r\n        // execute record suffix in Delete mode\r\n        // set the InDeleteProcess flag , so we will not try to send updates on the record after\r\n        // we delete it in the commonHandlerAfter (rec suffix).\r\n        rec.setInDeleteProcess(true);\r\n\r\n        task.setMode(Constants.TASK_MODE_DELETE);\r\n        // no confirm message dialog if in non interactive delete.\r\n        let skipConfirmDialog: boolean = nonInteractiveDelete;\r\n\r\n        if (!skipConfirmDialog) {\r\n          if (task.mustConfirmInDeleteMode() || await task.checkProp(PropInterface.PROP_TYPE_CONFIRM_UPDATE, false)) {\r\n            let confirmed: boolean = await GUIManager.Instance.confirm_bool(MsgInterface.CONFIRM_STR_DELETE);\r\n            if (!confirmed) {\r\n              rec.clearMode();\r\n              rec.setMode(oldRecMode);\r\n              task.setMode(Constants.TASK_MODE_MODIFY);\r\n              if (lastParkedCtrl !== null)\r\n                await this.handleInternalEventWithMgControlBase(lastParkedCtrl, InternalInterface.MG_ACT_CTRL_PREFIX);\r\n\r\n              if (saveIsRowEditing) {\r\n                let myform: MgForm = <MgForm>task.getForm();\r\n                await myform.startRowEditing(myform.DisplayLine);\r\n              }\r\n\r\n              return true;\r\n            }\r\n          }\r\n        }\r\n\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n        rec.setInDeleteProcess(false);\r\n\r\n        if (this._stopExecution) {\r\n          if (!rec.SendToServer) {\r\n            await dv.addCurrToModified();\r\n            rec.setSendToServer(true);\r\n          }\r\n\r\n          rec.clearMode();\r\n          rec.setMode(oldRecMode);\r\n          this.setStopExecution(false);\r\n          task.setMode(Constants.TASK_MODE_MODIFY);\r\n          await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n          this.setStopExecution(true);\r\n\r\n          return true;\r\n        }\r\n\r\n        // If we're deleting an inserted record, the server is not aware of it\r\n        // make sure that upon delete, it will be removed from the modified rec list\r\n        if (oldRecMode === DataModificationTypes.Insert) {\r\n          rec.clearMode();\r\n          rec.setMode(oldRecMode);\r\n        }\r\n\r\n        let newCurrRec: Record = dv.getCurrRec();\r\n\r\n        try {\r\n          // QCR #438175: when the user deletes a record, which is the single\r\n          // record in the dv, then when its record suffix is executed and the\r\n          // server sends a new record to the client and set it to be the\r\n          // current record.\r\n          // This fix makes the deleted record to be the current for a\r\n          // moment just to delete it from the clients cache. Then, it makes\r\n          // the new record to be the current again and enters into create mode.\r\n          // I think that a better solution is to decide whether the client is\r\n          // responsible for adding a new record or the server, and make sure\r\n          // that it is done systemwide.\r\n          // Ehud - 10/09/2001\r\n          if (rec !== newCurrRec)\r\n            await dv.setCurrRec(rec.getId(), false);\r\n\r\n          // no need to del the curr rec and position on the nex rec if the task is aborting.\r\n          // The delCurrRec may cause a crash if it tries to get the next rec from the next chunk.\r\n          if (!task.isAborting())\r\n            await this.delCurrRec(task, false);\r\n        } finally {\r\n          // QCR #438175 - fix continue\r\n          if (rec !== newCurrRec) {\r\n            await dv.setCurrRec(newCurrRec.getId(), false);\r\n            if (dv.getSize() === 1)\r\n              task.setMode(Constants.TASK_MODE_CREATE);\r\n          }\r\n          // In interactive, the mode might change to modify or create. However, for non interactive (delete mode)\r\n          // the mode should be set back to delete and will be used in the next record cycle.\r\n          if (nonInteractiveDelete)\r\n            task.setMode(Constants.TASK_MODE_DELETE);\r\n        }\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   handle view refresh, screen refresh and record flush events\r\n  /// </summary>\r\n  /// <param name = \"evt\">the event to handle with all its properties</param>\r\n  private async handleRefreshEvents(evt: RunTimeEvent): Promise<void> {\r\n    let task: Task = <Task>evt.getTask();\r\n    let form: MgForm = <MgForm>task.getForm();\r\n    let dv: DataView = <DataView>task.DataView;\r\n    let intEvtCode: number = evt.getInternalCode();\r\n    let cmd: IClientCommand = null;\r\n\r\n    if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_RECORD)\r\n      this._isInRecordFlushEvent = true;\r\n    // check if we try to view refresh with allow_modify=n in create mode\r\n    if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_VIEW && task.getMode() === Constants.TASK_MODE_CREATE && !await task.checkProp(PropInterface.PROP_TYPE_ALLOW_MODIFY, true)) {\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_EXIT);\r\n    } else {\r\n      await task.ExecuteNestedRS(LastFocusedManager.Instance.getLastFocusedTask());\r\n      if (!this.GetStopExecutionFlag()) {\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n      }\r\n      if (!this.GetStopExecutionFlag() && !task.InEndTask && !task.isAborting()) {\r\n        if (intEvtCode !== InternalInterface.MG_ACT_RT_REFRESH_SCREEN) {\r\n          let currentRow: number = 0;\r\n          if (!evt.getRefreshType()) {\r\n            if (evt.RtViewRefreshUseCurrentRow() && task.IsInteractive) {\r\n              currentRow = form.getCurrRecPosInForm();\r\n            }\r\n            cmd = CommandFactory.CreateInternalRefreshCommand(task.getTaskTag(), intEvtCode, dv.CurrentRecId, currentRow);\r\n          } else {\r\n            if (task.IsInteractive)\r\n              currentRow = form.getCurrRecPosInForm();\r\n\r\n            let refetchRecord: boolean = true; //Refetch record from server.\r\n            if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_RECORD && evt.getArgList() !== null && evt.getArgList().getSize() !== 0) {\r\n              let refetchRecStr: string;\r\n              refetchRecStr = await evt.getArgList().getArgValue(0, StorageAttribute.BOOLEAN, 0);\r\n              refetchRecord = (isNullOrUndefined(refetchRecStr) || refetchRecStr === '1');\r\n            }\r\n\r\n            if (refetchRecord)\r\n              cmd = await CommandFactory.CreateRealRefreshCommand(task.getTaskTag(), intEvtCode, currentRow, evt.getArgList(), dv.CurrentRecId);\r\n          }\r\n        }\r\n        // screen refresh event\r\n        else {\r\n          let id: number;\r\n\r\n          if (task.getForm() === null)\r\n            id = 0;\r\n          else if (task.getForm().isScreenMode())\r\n            id = ((<DataView>task.DataView).getCurrRec()).getId();\r\n          else\r\n            id = (<DataView>task.DataView).getRecByIdx((<DataView>task.DataView).getTopRecIdx()).getId();\r\n\r\n          cmd = CommandFactory.CreateScreenRefreshCommand(task.getTaskTag(), id, dv.CurrentRecId);\r\n        }\r\n\r\n        // real view refresh causes the cache of the current sub form task to be cleared\r\n        if (intEvtCode !== InternalInterface.MG_ACT_RT_REFRESH_SCREEN)\r\n        // screen refresh does not clear the cache\r\n          task.getTaskCache().clearCache();\r\n\r\n        if (cmd !== null)\r\n          await task.DataviewManager.Execute(cmd);\r\n\r\n        this._isInRecordFlushEvent = false;\r\n        // QCR #289222. Do not continue with Refresh if the task must be ended.\r\n        if (!this.GetStopExecutionFlag() && !task.InEndTask && !task.isAborting()) {\r\n          // After view refresh, the server always returns curr rec as first rec.\r\n          if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_VIEW && !form.isScreenMode()) {\r\n            dv.setTopRecIdx(0);\r\n            if (form.HasTable()) {\r\n              form.clearTableColumnSortMark(true);\r\n              await form.restoreOldDisplayLine(form.recordIdx2DisplayLine(dv.getCurrRecIdx()));\r\n            }\r\n          }\r\n\r\n          // After record has been flushed it is not considered a new record anymore.\r\n          if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_RECORD && task.getMode() !== Constants.TASK_MODE_QUERY && !task.getAfterRetry()) {\r\n            if (task.getMode() === Constants.TASK_MODE_CREATE) {\r\n              task.setMode(Constants.TASK_MODE_MODIFY);\r\n              ((<DataView>task.DataView).getCurrRec()).setOldRec();\r\n            }\r\n            await dv.currRecCompute(true);\r\n          } else if (intEvtCode === InternalInterface.MG_ACT_RT_REFRESH_SCREEN && task.getMode() !== Constants.TASK_MODE_QUERY && !task.getAfterRetry()) {\r\n            await dv.currRecCompute(true);\r\n          }\r\n\r\n          // QCR #430059. If the focused task and the refreshed task is the same task or\r\n          // the focused task is a child of the refreshed task, go to the first control in the first line.\r\n          // If the focused task is the parent task, do not leave the current control.\r\n          this.setIsInViewRefresh(true);\r\n          await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n          if (!this.GetStopExecutionFlag() && !task.getPreventControlChange()) {\r\n            if (!(task === LastFocusedManager.Instance.getLastFocusedTask() || !task.pathContains(LastFocusedManager.Instance.getLastFocusedTask())))\r\n              await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Go to create mode\r\n  /// </summary>\r\n  /// <param name = \"task\"></param>\r\n  /// <param name = \"cmds\"></param>\r\n  private async gotoCreateMode(task: Task): Promise<void> {\r\n    let cmd: IClientCommand;\r\n    await task.enableModes();\r\n    // QCR #417733. Execute RS's of the nested subforms if the current task is one of the nested subforms.\r\n    await task.ExecuteNestedRS(LastFocusedManager.Instance.getLastFocusedTask());\r\n    if (!this.GetStopExecutionFlag())\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n    if (!this.GetStopExecutionFlag()) {\r\n      cmd = CommandFactory.CreateEventCommand(task.getTaskTag(), InternalInterface.MG_ACT_RTO_CREATE);\r\n      await task.DataviewManager.Execute(cmd);\r\n      if (task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n        await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n      await this.HandleNonParkableControls(task);\r\n      await task.setCreateDeleteActsEnableState();\r\n      task.setOriginalTaskMode(Constants.TASK_MODE_CREATE);\r\n\r\n      await this.HandleActEnterRowEditing(task);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   do some default operations for an event after all the handlers finished\r\n  /// </summary>\r\n  /// <param name = \"rcBefore\">the RC returned from the commonHandlerBefore</param>\r\n  /// <param name = \"propogate\">if event was propogated</param>\r\n  /// <param name = \"Event\">the event to handle</param>\r\n  private async commonHandlerAfter(evt: RunTimeEvent, rcBefore: boolean): Promise<void> {\r\n    let task: Task = <Task>evt.getTask();\r\n    let dv: DataView;\r\n    let rec: Record = null;\r\n    let ctrl: MgControl;\r\n    let recModified: boolean = false;\r\n    let recModeIsDelete: boolean = false;\r\n    let forceSuffix: boolean;\r\n\r\n    if (this._stopExecution && evt.getInternalCode() !== InternalInterface.MG_ACT_REC_SUFFIX && evt.getInternalCode() !== InternalInterface.MG_ACT_CTRL_SUFFIX)\r\n      return;\r\n\r\n    if (evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {\r\n      dv = <DataView>task.DataView;\r\n      rec = dv.getCurrRec();\r\n      ctrl = <MgControl>evt.Control;\r\n\r\n      switch (evt.getInternalCode()) {\r\n        case InternalInterface.MG_ACT_REC_PREFIX:\r\n          if (rcBefore) {\r\n            // handle record prefix for the sub tasks too\r\n            if (await task.CheckRefreshSubTasks())\r\n              await task.doSubformRecPrefixSuffix();\r\n            await task.handleEventOnSlaveTasks(InternalInterface.MG_ACT_REC_PREFIX);\r\n            await task.enableModes();\r\n          }\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_REC_SUFFIX:\r\n          task.isFirstRecordCycle(false);\r\n          // Once are ready to end the RS, it means we cannot be the FIRST record cycle\r\n          if (task.getPreventRecordSuffix()) {\r\n            task.setPreventRecordSuffix(false);\r\n            return;\r\n          }\r\n\r\n          // QCR #115951. Even if record suffix is not executed, in the next time do not execute RP & RS of the subform.\r\n          task.DoSubformPrefixSuffix = false;\r\n\r\n          if (this._stopExecution) {\r\n            // QCR #984031: if the delete operation failed due to \"verify error\"\r\n            // in the record suffix then the record mode must be cleared\r\n            if (rec.getMode() === DataModificationTypes.Delete)\r\n              rec.clearMode();\r\n            // Qcr 783039 : If we are already in control level it means that control prefix was already done or that\r\n            // control suffix was not done. Either way there is no need to do control prefix again.\r\n            if (task.getLevel() !== Constants.TASK_LEVEL_CONTROL) {\r\n              let last = <MgControl>this.getStopExecutionCtrl();\r\n              if (last === null)\r\n                last = <MgControl>task.getLastParkedCtrl();\r\n\r\n              this.setStopExecution(false);\r\n              this.setStopExecutionCtrl(null);\r\n\r\n              // QCR 426283 is we have a sub-form that was never been entered\r\n              // make sure control level will not be entered\r\n              if (last != null) {\r\n                // we donot want CS to be called again from CP incase of verify err in CV\r\n                task.setLevel(Constants.TASK_LEVEL_RECORD);\r\n\r\n                let inCtrlPrefix: boolean = task.InCtrlPrefix;\r\n                task.InCtrlPrefix = false;\r\n                await this.handleInternalEventWithMgControlBase(last, InternalInterface.MG_ACT_CTRL_PREFIX);\r\n                task.InCtrlPrefix = inCtrlPrefix;\r\n              }\r\n\r\n              // in the future check the stopExecution flag here too and display a\r\n              // confirm cancel dialog that will close the browser if the value is true\r\n              this.setStopExecution(true);\r\n            }\r\n            return;\r\n          } else {\r\n            // Defect 152871: With new way of editing row, RS is not fired infinitely, but row selection is shifted to new row. Also row leaves editing mode.\r\n            // So ensure row editing is left when there is no verify error and not unconditionally.\r\n            await this.HandleStopRowEditing(task);\r\n          }\r\n\r\n          if (rec != null) {\r\n            recModified = rec.Modified;\r\n            if (!this._stopExecution && rec.isCauseInvalidation()) {\r\n              (<MgForm>task.getForm()).invalidateTable();\r\n              rec.setCauseInvalidation(false);\r\n            }\r\n            recModeIsDelete = (rec.getMode() === DataModificationTypes.Delete);\r\n\r\n            forceSuffix = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);\r\n            // if the record is deleted then execute the \"rec suffix after\" only\r\n            // when the task mode is delete (second round)\r\n            // inDeleteProcess : if there is an 'END TASK COND' we will have a 3rd cycle in record suffix(when upd+del or force suff + del).\r\n            // 1st cycle : updae cycle (task mode will be update), 2nd : task mode is delete , this is when we send the delete to the server.\r\n            // 3rd - suffix that is called from the endTask. In the 3rd cycle the recModeIsDelete will be false although we are still in the delete process (we already sent the delete oper).\r\n            // A combination of force suffix + end task cond + del line , will crash the server on the 3rd cycle since we will ask for update off\r\n            // a record that the server had deleted on the 2nd cycle. That it why we use 'inDeleteProcess', so will will know not\r\n            // to add update oper on an already deleted record. (Qcr #790283).\r\n            // * there is still a problem in 'update' and 'insert' with 'end task cond' + 'force' : an extra update will be send\r\n            //   to the server on the rec suffix of the end task. but apart from server update it causes no real problem.\r\n            if (recModeIsDelete && task.getMode() === Constants.TASK_MODE_DELETE ||\r\n              !recModeIsDelete && !rec.inDeleteProcess() && (recModified || forceSuffix)) {\r\n              rec.setMode(DataModificationTypes.Update);\r\n              await dv.addCurrToModified();\r\n              dv.setChanged(true);\r\n\r\n              if (recModified && task.getMode() === Constants.TASK_MODE_QUERY) {\r\n                if (rec.realModified() &&\r\n                  !Environment.Instance.allowUpdateInQueryMode(task.getCompIdx())) {\r\n                  // if real fields were modified\r\n                  await dv.cancelEdit(EventsManager.REAL_ONLY, false);\r\n                  task.WriteToMessagePanebyMsgId(MsgInterface.RT_STR_UPDATE_IN_QUERY);\r\n                  await (<MgForm>task.getForm()).RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n                }\r\n                // we must continue here and try to commit the transaction because\r\n                // there might be also some sub tasks to this task\r\n              }\r\n            }\r\n\r\n            // QCR#776295: for pre record update, commit the record after handler's execution.\r\n            // Fixed bug #:306929, ForceExitPre is relevant only for the task that raised the event\r\n            // see also bug#:292876\r\n            if (!this.isForceExitPreRecordUpdate(task) &&\r\n              // Defect 154047 : do not try and commit if task is aborting and was already removed (or all MGD was removed).\r\n              (!task.isAborting() || MGDataCollection.Instance.GetTaskByID(task.getTaskTag()) != null)) {\r\n              if ((!recModeIsDelete || task.getMode() === Constants.TASK_MODE_DELETE))\r\n                await this.commitRecord(task, evt.reversibleExit());\r\n            }\r\n\r\n            if (!task.transactionFailed(ConstInterface.TRANS_RECORD_PREFIX) && !task.isAborting()) {\r\n              // check whether to evaluate the end condition after the record suffix\r\n              // in case there are 2 cycles (update/force suffix + delete), do the end task only in the 2nd cycle.\r\n              if ((rec.getMode() === DataModificationTypes.Delete &&\r\n                task.getMode() === Constants.TASK_MODE_DELETE) ||\r\n                rec.getMode() !== DataModificationTypes.Delete)\r\n                if (await task.evalEndCond(ConstInterface.END_COND_EVAL_AFTER))\r\n                  await task.endTask(true, false, false);\r\n            }\r\n          } // rec != null\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_PREFIX:\r\n          if (rcBefore) {\r\n            // check parkability once again as property might have changed in the handler\r\n            // 924112 - ignore direction (if flag set) as we are forcing park inspite of failed direction\r\n            // QCR# 806015: If we have a single field with allow parking = Yes and Tab Into = No, then on pressing tab if cursor is not\r\n            // moved, we come to park on lastParkedCtrl (which is same as ctrl) since TabInto is not allowed.\r\n            // So to avaoid infinite recursion, we should not again try to park on it.\r\n            if (await ctrl.IsParkable() || ctrl === LastFocusedManager.getLastFocusedControl()) {\r\n              // set InControl true after Control Prefix\r\n              ctrl.InControl = true;\r\n\r\n              if (ctrl.ShouldRefreshOnControlEnter())\r\n                await (<Field>ctrl.getField()).updateDisplay();\r\n\r\n              // if this code is reached then everything is ok in the control prefix\r\n              // user handler. Now, move the focus to the control.\r\n              task.setLastParkedCtrl(ctrl);\r\n              // we have parked on a ctrl set clicked ctrl to null\r\n              RuntimeContextBase.Instance.CurrentClickedCtrl = null;\r\n\r\n              // to take care of temporary editor\r\n              // Manager.setFocus(ctrl, ctrl.getDisplayLine(false));\r\n              await ctrl.SetFocus(ctrl, ctrl.getDisplayLine(false), true);\r\n              // we have successfully parked on a ctrl, set setstopexecutionCtrl to null\r\n              this.setStopExecutionCtrl(null);\r\n\r\n              MgControl.ReturnToCtrl = ctrl;\r\n              task.InCtrlPrefix = false;\r\n            } else {\r\n              task.InCtrlPrefix = false;\r\n              await this.HandleNonParkableControls(ctrl.getForm().getTask());\r\n            }\r\n          }\r\n\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_CTRL_SUFFIX:\r\n          // disable actions and states. do it only if we are getting out of the control.\r\n          if (!this.GetStopExecutionFlag()) {\r\n\r\n            if (ctrl.isChoiceControl()) {\r\n              ctrl.SetKeyboardLanguage();\r\n            }\r\n            if (ctrl.Type === MgControlType.CTRL_TYPE_BUTTON)\r\n              task.ActionManager.enable(InternalInterface.MG_ACT_BUTTON, false);\r\n\r\n            if (task.getEnableZoomHandler() || ctrl.useZoomHandler())\r\n              task.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, false);\r\n            task.ActionManager.enable(InternalInterface.MG_ACT_RT_EDT_NULL, false);\r\n\r\n          }\r\n\r\n          if (rcBefore) {\r\n            if (this.GetStopExecutionFlag()) {\r\n              // If control suffix get 'stop execution' (e.g. verify error), the focus will be remain on current control.\r\n              // So set InControl to true\r\n              ctrl.InControl = true;\r\n              return;\r\n            }\r\n\r\n\r\n            // Update fields that are assigned to a text control and with type that has default display\r\n            // value (numeric, date, time, logical etc)\r\n            let fld: Field = <Field>ctrl.getField();\r\n            if (fld != null && (ctrl.Type === MgControlType.CTRL_TYPE_TEXT))\r\n              await fld.updateDisplay();\r\n\r\n            task.setLevel(Constants.TASK_LEVEL_RECORD);\r\n            ctrl.setInControlSuffix(false);\r\n            ctrl.IsInteractiveUpdate = false;\r\n            if (ctrl.PropertyExists(PropInterface.PROP_TYPE_CUSTOM_VALIDATORS))\r\n              await ctrl.getProp(PropInterface.PROP_TYPE_CUSTOM_VALIDATORS).RefreshDisplay(true);\r\n            ctrl.ValidateControl = false;\r\n            LastFocusedManager.setLastFocusedControl(task, null);\r\n\r\n            if (await task.evalEndCond(ConstInterface.END_COND_EVAL_IMMIDIATE))\r\n              await task.endTask(true, false, false);\r\n          }\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_TASK_PREFIX:\r\n          task.setLevel(Constants.TASK_LEVEL_TASK);\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_TASK_SUFFIX:\r\n          task.setLevel(Constants.TASK_LEVEL_NONE);\r\n          break;\r\n\r\n        // simulates user asking for the next rec.\r\n        case InternalInterface.MG_ACT_CYCLE_NEXT_REC:\r\n          let form = <MgForm>task.getForm();\r\n          if (!task.isMainProg() && form != null) {\r\n            await form.moveInView(form.isLineMode()\r\n              ? Constants.MOVE_UNIT_ROW\r\n              : Constants.MOVE_UNIT_PAGE,\r\n              Constants.MOVE_DIRECTION_NEXT);\r\n            // end of data will signal us to end the task (unless in create mode).\r\n            if (task.getExecEndTask())\r\n              await task.endTask(true, false, false);\r\n          }\r\n          break;\r\n\r\n        // delete record in non interactive task\r\n        case InternalInterface.MG_ACT_CYCLE_NEXT_DELETE_REC:\r\n          // check empty dataview before trying to delete, in case task started with empty dataview.\r\n          if (task.DataView.isEmptyDataview())\r\n            (task).setExecEndTask();\r\n          else\r\n            await this.HandleActionDelline( task, dv, rec, true);\r\n\r\n          // end of data will signal us to end the task (unless in create mode).\r\n          if (task.getExecEndTask())\r\n            await task.endTask(true, false, false);\r\n          break;\r\n\r\n        case InternalInterface.MG_ACT_SET_EXTERNAL_VALUE:\r\n          let refreshDisplay : boolean = await evt.getArgList().getArgValue(1, StorageAttribute.BOOLEAN, 0) === '1' ? true : false;\r\n          await (<MgControl>ctrl).validateAndSetValueIfAllowed(evt.getValue(), refreshDisplay);\r\n          break;\r\n\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   creates a non reversible event and handle it\r\n  /// </summary>\r\n  /// <param name = \"task\">a reference to the task </param>\r\n  /// <param name = \"eventCode\">the code of the event </param>\r\n  async handleNonReversibleEvent(task: TaskBase, eventCode: number): Promise<void> {\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(task);\r\n    let exitCommand: boolean = (eventCode === InternalInterface.MG_ACT_EXIT || eventCode === InternalInterface.MG_ACT_CLOSE);\r\n\r\n    rtEvt.setInternal(eventCode);\r\n\r\n    if (exitCommand)\r\n      this._isNonReversibleExit = true;\r\n\r\n    try {\r\n      rtEvt.setNonReversibleExit();\r\n      rtEvt.setCtrl(<MgControl>task.getLastParkedCtrl());\r\n      rtEvt.setArgList(null);\r\n      await this.handleEvent(rtEvt, false);\r\n    } finally {\r\n      if (exitCommand)\r\n        this._isNonReversibleExit = false;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   creates a new internal Event and handle it\r\n  /// </summary>\r\n  /// <param name = \"task\">a reference to the task</param>\r\n  /// <param name = \"eventCode\">the code of the event</param>\r\n  /// <param name = \"isQuit\">indicates whether MG_ACT_CANCEL is called from MG_ACT_RT_QUIT</param>\r\n  async handleInternalEventWithTaskAndEventSubtype(task: TaskBase, eventCode: number, eventSubType: EventSubType): Promise<void> {\r\n    let lastParkedCtrl: MgControl = <MgControl>task.getLastParkedCtrl();\r\n    let rtEvt: RunTimeEvent;\r\n\r\n    if (eventCode < InternalInterface.MG_ACT_TOT_CNT && task != null && !(eventSubType === EventSubType.CancelIsQuit) && !task.ActionManager.isEnabled(eventCode))\r\n      return;\r\n\r\n    if (lastParkedCtrl !== null)\r\n      await this.handleInternalEventWithMgControl(lastParkedCtrl, eventCode, eventSubType);\r\n\r\n    else {\r\n      if (eventCode === InternalInterface.MG_ACT_RT_QUIT)\r\n        await this.handleInternalEventWithTaskAndEventSubtype(task, InternalInterface.MG_ACT_CANCEL, EventSubType.CancelIsQuit);\r\n      else {\r\n        rtEvt = new RunTimeEvent(task);\r\n        rtEvt.setInternal(eventCode);\r\n        rtEvt.SetEventSubType(eventSubType);\r\n        if (InternalInterface.BuiltinEvent(eventCode))\r\n          await this.handleEvent(rtEvt, false);\r\n        else\r\n          await this.commonHandler(rtEvt);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   creates a new internal Event and handle it\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">a reference to the control</param>\r\n  /// <param name = \"eventCode\">the code of the event</param>\r\n  /// <param name = \"isQuit\">indicates whether MG_ACT_CANCEL is called from MG_ACT_RT_QUIT</param>\r\n  private async handleInternalEventWithMgControl(ctrl: MgControl, eventCode: number, eventSubType: EventSubType): Promise<void> {\r\n    let rtEvt: RunTimeEvent;\r\n\r\n    if (eventCode === InternalInterface.MG_ACT_RT_QUIT)\r\n      await this.handleInternalEventWithMgControl(ctrl, InternalInterface.MG_ACT_CANCEL, EventSubType.CancelIsQuit);\r\n    else {\r\n      rtEvt = new RunTimeEvent(ctrl);\r\n      rtEvt.setInternal(eventCode);\r\n      rtEvt.SetEventSubType(eventSubType); // (use for act_cancel & act_rt_view_refresh\r\n      // basically MG_ACT_VIEW_REFRESH represent the view refresh event raised by the user\r\n      // however we use internally in the code to refresh the display (mainly in sub forms refreshes)\r\n      // in order the distinguish between the real use and the internal use we set this flag to false\r\n      // we need to distinguish between the two since we make different actions when caching a subform\r\n      if (eventCode === InternalInterface.MG_ACT_RT_REFRESH_VIEW)\r\n        rtEvt.setIsRealRefresh(false);\r\n\r\n      if (InternalInterface.BuiltinEvent(eventCode))\r\n        await this.handleEvent(rtEvt, false);\r\n      else\r\n        await this.commonHandler(rtEvt);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the current field\r\n  /// </summary>\r\n  getCurrField(): Field {\r\n    return this._currField;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns current control\r\n  /// </summary>\r\n  getCurrCtrl(): MgControl {\r\n    return this._currCtrl;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the current task\r\n  /// </summary>\r\n  getCurrTask(): Task {\r\n    if (this._currField == null)\r\n      return null;\r\n    return <Task>this._currField.getTask();\r\n  }\r\n\r\n  setStopExecution(stop: boolean): void;\r\n  setStopExecution(stop: boolean, clearEventsOnStopExecution : ClearEventsOnStopExecution): void ;\r\n  setStopExecution(stop: boolean, clearEventsOnStopExecution? : ClearEventsOnStopExecution): void {\r\n    if (arguments.length === 1)\r\n      this.setStopExecution_0(stop);\r\n    else\r\n      this.setStopExecution_1(stop, clearEventsOnStopExecution);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the \"stop execution\" flag to true\r\n  /// </summary>\r\n  private setStopExecution_0(stop: boolean): void {\r\n    this.setStopExecution(stop, ClearEventsOnStopExecution.ALL);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the \"stop execution\" flag to true\r\n  /// </summary>\r\n  private setStopExecution_1(stop: boolean, clearEventsOnStopExecution: ClearEventsOnStopExecution): void {\r\n    if (stop)\r\n      if (clearEventsOnStopExecution == ClearEventsOnStopExecution.ALL)\r\n        this._eventsQueue.clear();\r\n      else if(clearEventsOnStopExecution == ClearEventsOnStopExecution.SERVER) {\r\n        let tmpVec = new List<RunTimeEvent>();\r\n        let rtEvt: RunTimeEvent;\r\n        let i: number;\r\n\r\n        // We were requested to leave the \"server events\" in the queue.\r\n        // Do it, but also remove the \"protection\" from these events so next\r\n        // time we need to clear the queue they will also be deleted.\r\n        while (!this._eventsQueue.isEmpty()) {\r\n          rtEvt = <RunTimeEvent>this._eventsQueue.poll();\r\n          if (rtEvt.isFromServer()) {\r\n            rtEvt.resetFromServer();\r\n            tmpVec.push(rtEvt);\r\n          }\r\n        }\r\n\r\n        for (i = 0; i < tmpVec.length; i++)\r\n          this._eventsQueue.put(tmpVec.get_Item(i));\r\n      }\r\n    this._stopExecution = stop;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the ctrl on which we had a \"stop execution\"\r\n  /// </summary>\r\n  setStopExecutionCtrl(ctrl: MgControl): void {\r\n    if (this._stopExecutionCtrl === null || ctrl === null)\r\n      this._stopExecutionCtrl = ctrl;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   delete the current record\r\n  /// </summary>\r\n  /// <param name = \"task\">the task to refer to </param>\r\n  /// <param name = \"inForceDel\">true if the delete is done because of force delete </param>\r\n  private async delCurrRec(task: Task, inForceDel: boolean): Promise<void> {\r\n    let dv: DataView = <DataView>task.DataView;\r\n\r\n    task.setMode(Constants.TASK_MODE_MODIFY);\r\n\r\n    // delete the record and run record suffix for the new current record\r\n    await (<MgForm>task.getForm()).delCurrRec();\r\n\r\n    // no curr-rec ==> we deleted the last record and failed to create a new one (e.g.\r\n    // CREATE mode is not allowed) ==> end the task. An exception to the rule is when\r\n    // we are already in the process of creating a record.\r\n    if (!task.DataView.isEmptyDataview()) {\r\n      if (dv.getCurrRecIdx() >= 0) {\r\n        // QCR #656495: If we got to this point and the current record is still the\r\n        // deleted one then the record prefix will be handled elsewhere.\r\n        if ((dv.getCurrRec()).getMode() !== DataModificationTypes.Delete && !inForceDel) {\r\n          let ctrl: MgControl = <MgControl>task.getLastParkedCtrl();\r\n          await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n          if (!this.GetStopExecutionFlag())\r\n            if (ctrl === null)\r\n              await this.HandleNonParkableControls(task);\r\n            else\r\n              await this.handleInternalEventWithMgControlBase(ctrl, InternalInterface.MG_ACT_CTRL_PREFIX);\r\n        }\r\n      } else if (!task.getInCreateLine())\r\n        await this.handleNonReversibleEvent(task, InternalInterface.MG_ACT_EXIT);\r\n    } else {\r\n      await this.HandleNonParkableControls(task);\r\n      await this.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_PREFIX);\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   process users confirmation\r\n  /// </summary>\r\n  /// <param name = \"task\">to check confirm update</param>\r\n  /// <returns> true - process command, false - stop command processing</returns>\r\n  private async updateConfirmed(task: Task): Promise<boolean> {\r\n    let confirm: boolean;\r\n    let answer: string;\r\n    let ans: number;\r\n\r\n    if (task == null)\r\n      return false;\r\n\r\n    confirm = await task.checkProp(PropInterface.PROP_TYPE_CONFIRM_UPDATE, false);\r\n    if (!this._isInRecordFlushEvent && confirm && !task.DataSynced) {\r\n      ans = await GUIManager.Instance.confirm(MsgInterface.CRF_STR_CONF_UPD,\r\n        Styles.MSGBOX_ICON_QUESTION | Styles.MSGBOX_BUTTON_YES_NO_CANCEL);\r\n      if (ans === Styles.MSGBOX_RESULT_YES)\r\n        answer = 'Y';\r\n      // Yes\r\n      else if (ans === Styles.MSGBOX_RESULT_NO)\r\n        answer = 'N';\r\n      // No\r\n      else\r\n        answer = 'C'; // Cancel\r\n    } else\r\n      answer = 'Y';\r\n\r\n    switch (answer) {\r\n      case 'Y':\r\n        break;\r\n\r\n      case 'N':\r\n        await (<MgForm>task.getForm()).cancelEdit(false, false);\r\n        await (<MgForm>task.getForm()).RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n        task.ConfirmUpdateNo = true;\r\n        return false; // not continue record suffix\r\n\r\n      case 'C':\r\n        this.setStopExecution(true);\r\n        this.setStopExecutionCtrl(LastFocusedManager.getLastFocusedControl());\r\n        await FocusManager.SetFocus(LastFocusedManager.getLastFocusedControl(), -1);\r\n        return false; // stop event processing\r\n\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg('in ClientManager.Instance.updateConfirmed() illegal confirmation code: ' +\r\n          confirm);\r\n        break;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Set the order of handling main programs of components\r\n  /// </summary>\r\n  setCompMainPrgTab(compMainPrgTable: CompMainPrgTable): void {\r\n    this._compMainPrgTab = compMainPrgTable;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set end of work flag\r\n  /// </summary>\r\n  setEndOfWork(endOfWork_: boolean): void {\r\n    this._endOfWork = endOfWork_;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get end of work flag\r\n  /// </summary>\r\n  getEndOfWork(): boolean {\r\n    return this._endOfWork;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the order of handling main programs of components\r\n  /// </summary>\r\n  getCompMainPrgTab(): CompMainPrgTable {\r\n    return this._compMainPrgTab;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the reversible exit flag\r\n  /// </summary>\r\n  inNonReversibleExit(): boolean {\r\n    return this._isNonReversibleExit;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   push a runtime event to the stack\r\n  /// </summary>\r\n  /// <param name = \"rtEvt\">the runtime event to push on the stack</param>\r\n  pushRtEvent(rtEvt: RunTimeEvent): void {\r\n    this._rtEvents.push(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pop a runtime event from the stack and return it\r\n  /// </summary>\r\n  popRtEvent(): RunTimeEvent {\r\n    if (this._rtEvents.count() === 0)\r\n      return null;\r\n    return <RunTimeEvent>this._rtEvents.pop();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   store the last saved route event on local storage.\r\n  /// </summary>\r\n  storeLastSavedRouteEventOnLocalStorage(): void\r\n  {\r\n    let dataStorage = window.localStorage;\r\n    if (this.getLastSavedRouteEvent() != null)\r\n    {\r\n      let rtEvt = this.getLastSavedRouteEvent();\r\n\r\n      dataStorage.setItem(ConstInterface.LAST_ROUTE_EVENT, '1');\r\n      dataStorage.setItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK, JSON.stringify((<Task>rtEvt.getTask()).TaskDefinitionId));\r\n\r\n      if (rtEvt.getArgList().getSize() > 0) {\r\n        let str: StringBuilder = new StringBuilder();\r\n        rtEvt.getArgList().buildXML(str);\r\n        dataStorage.setItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST,  str.toString());\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   restore the last saved route event from local storage.\r\n  /// </summary>\r\n  restoreLastSavedRouteEventFromLocalStorage(): void\r\n  {\r\n    //get route event if stored on local storage\r\n    let dataStorage = window.localStorage;\r\n\r\n    let lastRouteEvent = dataStorage.getItem(ConstInterface.LAST_ROUTE_EVENT);\r\n\r\n    if (lastRouteEvent === '1') {\r\n      let srcTaskDefinitionStr = dataStorage.getItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK);\r\n      let routeArgListStr = dataStorage.getItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST);\r\n\r\n      // parse srcTaskDefinitionStr and prepare taskDefinitionId\r\n      let taskDefinitionId = new TaskDefinitionId();\r\n      taskDefinitionId.fromJSON(srcTaskDefinitionStr);\r\n\r\n      //search source task in newly loaded task tree by taskDefinitionId\r\n      let srcTask = MGDataCollection.Instance.getCurrMGData().getTaskByTaskDefinitionID(taskDefinitionId);\r\n      let args = null;\r\n      if (routeArgListStr != null) {\r\n        args = new ArgumentsList();\r\n        args.fillList(routeArgListStr, srcTask);\r\n      }\r\n\r\n      EventsManager.Instance.AddLastSavedRouteEvent(srcTask, args);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the last saved route event.\r\n  /// </summary>\r\n  getLastSavedRouteEvent(): RunTimeEvent {\r\n      return this.lastSavedRouteEvent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///  save the last route event.\r\n  /// </summary>\r\n  setLastSavedRouteEvent (rtEvt:RunTimeEvent): void {\r\n    if (rtEvt == null)\r\n      this.lastSavedRouteEvent = null;\r\n    else\r\n      this.lastSavedRouteEvent = rtEvt.replicate();\r\n  }\r\n  /// <summary>\r\n  ///   return the runtime event located on the top of the stack\r\n  /// </summary>\r\n  getLastRtEvent(): RunTimeEvent {\r\n    if (this._rtEvents.count() === 0)\r\n      return null;\r\n    return <RunTimeEvent>this._rtEvents.peek();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of a flag which indicates whether we should ignore unknown commands\r\n  ///   arriving from the engine.\r\n  /// </summary>\r\n  setIgnoreUnknownAbort(val: boolean): void {\r\n    this._ignoreUnknownAbort = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value of the \"ignore unknown abort\" flag\r\n  /// </summary>\r\n  ignoreUnknownAbort(): boolean {\r\n    return this._ignoreUnknownAbort;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   recover from a failure to overlay a task. When the server orders the client to run a\r\n  ///   new task in a frame which already contains an active task, the client tries to term the\r\n  ///   existing task and replace him. When this action fails, the client has to ask the server\r\n  ///   to terminate the NEW TASK, and ignore the overlay action.\r\n  /// </summary>\r\n  /// <param name = \"taskid\">- the id of the NEW TASK</param>\r\n  /// <param name = \"mgd\">   - the MGData of the OLD TASK.</param>\r\n  async failTaskOverlay(taskId: string, mgd: MGData): Promise<void> {\r\n    let cmd: IClientCommand;\r\n\r\n    if (taskId !== null) {\r\n      // The server will return us 'abort' commands for the new task. Ignore them, since it wasnt started yet\r\n      this.setIgnoreUnknownAbort(true);\r\n      try {\r\n        cmd = CommandFactory.CreateNonReversibleExitCommand(taskId, false);\r\n        mgd.CmdsToServer.Add(cmd);\r\n        await RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n      } finally {\r\n        this.setIgnoreUnknownAbort(false);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns TRUE if current event should be propogtated to all tasks in a specific transaction\r\n  /// </summary>\r\n  isEventScopeTrans(): boolean {\r\n    return this._eventScope === EventScope.TRANS;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set event scope to TRANSACTION\r\n  /// </summary>\r\n  setEventScopeTrans(): void {\r\n    this._eventScope = EventScope.TRANS;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set event scope to NON TRANSACTION\r\n  /// </summary>\r\n  clearEventScope(): void {\r\n    this._eventScope = EventScope.NONE;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get time of fist event in sequence\r\n  /// </summary>\r\n  /// <returns> time of fitst event in sequence</returns>\r\n  GetEventTime(): number {\r\n    return this._eventsQueue.GetTime();\r\n  }\r\n\r\n  /// <param name = \"task\"></param>\r\n  /// <param name = \"kbItm\"></param>\r\n  /// <returns> the last enabled action for the specific key (in kbItem)</returns>\r\n  /// <checkAccessKeyInMenus:>  if to check the keyboard in the menu </checkAccessKeyInMenus:>\r\n  public getMatchingAction(  kbItm: KeyboardItem): number {\r\n\r\n    let act: number = 0;\r\n    // when menu is define with no keyboard define, the kbItem is return null;\r\n    if (kbItm == null)\r\n      return act;\r\n\r\n\r\n    // There was no kbd mapping the that key, but it still belongs to an action.\r\n    // see if the kbItm hold an action (originally made for MG_ACT_CHAR).\r\n    if (act === 0) {\r\n      // if menu was found and it is internal event put action to the queue only if there was no kbd mapping the that key.\r\n      if (kbItm.getAction() !== 0)\r\n        act = kbItm.getAction();\r\n      // this is only TEMP hardcoded. the action will need to be in the keyboard mapping\r\n      // also a change to the online (if time permits) also to turn the toggle insert into an act.\r\n      else if (kbItm.getKeyCode() === 45 && kbItm.getModifier() === Modifiers.MODIFIER_NONE && kbItm.getStates() === 0)\r\n        act = InternalInterface.MG_ACT_TOGGLE_INSERT;\r\n    }\r\n\r\n    return (act);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   getter for the execStack\r\n  /// </summary>\r\n  /// <returns> the current execution stack</returns>\r\n  getExecStack(): ExecutionStack {\r\n    return <ExecutionStack>this._execStack.peek();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pushes one entry of an operation into the execution stack\r\n  /// </summary>\r\n  /// <param name = \"taskId\">- the id of the current task</param>\r\n  /// <param name = \"handlerId\">- the id of the handler which holds the raise event command </param>\r\n  /// <param name = \"operIdx\">- the idx of the command which created an execution stack entry (raise event of function call)</param>\r\n  pushExecStack(taskId: string, handlerId: string, operIdx: number): void {\r\n    (<ExecutionStack>this._execStack.peek()).push(MGDataCollection.Instance.getTaskIdById(taskId), handlerId, operIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pops one entry from the execution stack - after the completion of an operation which can hold\r\n  ///   other operations\r\n  /// </summary>\r\n  /// <returns> the entry that was popped</returns>\r\n  popExecStack(): ExecutionStackEntry {\r\n    return (<ExecutionStack>this._execStack.peek()).pop();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   push a new entry to the stack of server exec stacks - this is to defer operations that should not\r\n  ///   get influences by the current server execution stack - when performing the record prefix of a task\r\n  ///   that was just returned from the server, or when calling a modal task\r\n  /// </summary>\r\n  pushNewExecStacks(): void {\r\n    this._serverExecStack.push(null);\r\n    this._execStack.push(new ExecutionStack());\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pops the new entry from the stack of server execution stacks when the sequence that needs to avoid\r\n  ///   current server execution stack has ended\r\n  /// </summary>\r\n  popNewExecStacks(): void {\r\n    this._serverExecStack.pop();\r\n    this._execStack.pop();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pushes an execution stack entry into the server exec stack\r\n  /// </summary>\r\n  /// <param name = \"taskId\">- the id of the task in the entry</param>\r\n  /// <param name = \"handlerId\">- handler id of the entry</param>\r\n  /// <param name = \"operIdx\">- idx of the operation which the entry refers to</param>\r\n  pushServerExecStack(taskId: string, handlerId: string, operIdx: number): void {\r\n    if (this._serverExecStack.peek() === null) {\r\n      this._serverExecStack.pop();\r\n      this._serverExecStack.push(new ExecutionStack());\r\n    }\r\n\r\n    (<ExecutionStack>this._serverExecStack.peek()).push(taskId, handlerId, operIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   clears the server execution stack after we found the correct next operation that we need to continue from\r\n  /// </summary>\r\n  clearServerExecStack(): void {\r\n    if (this._serverExecStack.peek() !== null) {\r\n      (<ExecutionStack>this._serverExecStack.peek()).clear();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reverse the server execution stack - we get it from the server and push it in the same order\r\n  ///   it is written in the message, which actually means we have to reverse it in order to handle it correctly\r\n  /// </summary>\r\n  reverseServerExecStack(): void {\r\n    if (this._serverExecStack.peek() !== null)\r\n      (<ExecutionStack>this._serverExecStack.peek()).reverse();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   calculate according to the server's execution stack and the current execution stack on the client +\r\n  ///   the current operation which we are on, which is the next operation that we need to execute\r\n  ///   in the current handler\r\n  /// </summary>\r\n  /// <param name = \"oper\">- the operation which we are currently on</param>\r\n  /// <param name = \"clearWhenFound\">indicates whether we should clear the server stack when we reach its end,\r\n  ///   or if we just using this method to check what the next operation is\r\n  /// </param>\r\n  /// <returns>s the next operation that should be executed by the client\r\n  ///   if it returns -1 then the client should continue as usual\r\n  /// </returns>\r\n  getNextOperIdx(oper: Operation, clearWhenFound: boolean): number {\r\n    let tmpServerExecStackEntry: ExecutionStackEntry = null;\r\n    let nextOperIdx: number = -1;\r\n\r\n    // if the server exec stack is empry it means we did not return from the server,\r\n    // so we have to continue with executing the following operation in the current handler as usual\r\n    if (this._serverExecStack.count() !== 0 && this._serverExecStack.peek() !== null && !(<ExecutionStack>this._serverExecStack.peek()).empty()) {\r\n      // if the server's exec stack is deeper than the client's -\r\n      // we need to check the entry in the client's stack which corresponds to the server's stack size\r\n      if ((<ExecutionStack>this._serverExecStack.peek()).size() > (<ExecutionStack>this._execStack.peek()).size()) {\r\n        // we copy the server's execution stack and pop from it until the size of the server\r\n        // and the client is the same\r\n        let tmpServerExecStack: ExecutionStack = new ExecutionStack(<ExecutionStack>this._serverExecStack.peek());\r\n        while (tmpServerExecStack.size() > (<ExecutionStack>this._execStack.peek()).size()) {\r\n          tmpServerExecStackEntry = tmpServerExecStack.pop();\r\n        }\r\n\r\n        // if all entries before the last one we popped are the same as in the client and\r\n        // the current entry is on the same handler as the server's last entry,\r\n        // and the operation is after the current operation,\r\n        // then this entry in the server indicates which is our next operation\r\n        if (this._execStack.peek().Equals(tmpServerExecStack) && tmpServerExecStackEntry.TaskId === oper.getTaskTag() && tmpServerExecStackEntry.HandlerId === oper.getHandlerId() && tmpServerExecStackEntry.OperIdx >= oper.getServerId()) {\r\n          nextOperIdx = tmpServerExecStackEntry.OperIdx;\r\n\r\n          // if the server exec stack is deeper than the client's by only 1,\r\n          // which means we are checking the top most entry on the server's execution stack,\r\n          // the whole stack is the same now, so we can clear the server's stack -\r\n          // we got to the point which we are on the exact operation which the server left execution.\r\n          if (clearWhenFound && (<ExecutionStack>this._serverExecStack.peek()).size() === (<ExecutionStack>this._execStack.peek()).size() + 1) {\r\n            (<ExecutionStack>this._serverExecStack.peek()).clear();\r\n          }\r\n        } else\r\n          nextOperIdx = EventsManager.MAX_OPER;\r\n      } else {\r\n        nextOperIdx = EventsManager.MAX_OPER;\r\n      }\r\n    }\r\n    return nextOperIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the processingTopMostEndTask\r\n  /// </summary>\r\n  /// <param name = \"inProcessingTopMostEndTask\"></param>\r\n  setProcessingTopMostEndTask(inProcessingTopMostEndTask: boolean): void {\r\n    this._processingTopMostEndTask = inProcessingTopMostEndTask;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   get the processingTopMostEndTask\r\n  /// </summary>\r\n  getProcessingTopMostEndTask(): boolean {\r\n    return this._processingTopMostEndTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the AllowEvents\r\n  /// </summary>\r\n  /// <param name = \"AllowEvents\"></param>\r\n  setAllowEvents(AllowEvents: EventsAllowedType): void {\r\n    this._allowEvents = AllowEvents;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the AllowEvents for a non interactive task.\r\n  /// </summary>\r\n  /// <param name = \"AllowEvents\"></param>\r\n  setNonInteractiveAllowEvents(AllowEvents: boolean): void {\r\n    if (AllowEvents)\r\n\r\n      this._allowEvents = EventsAllowedType.NON_INTERACTIVE;\r\n    // QCR #802495, The Forms Controller mechanism is disable if we are in Non interactive task with AllowEvents = true and Open Window = true\r\n\r\n    else\r\n      this._allowEvents = EventsAllowedType.NONE;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the AllowEvents\r\n  /// </summary>\r\n  /// <param name = \"withinNonInteractiveLoop\"></param>\r\n  getAllowEvents(): EventsAllowedType {\r\n    return this._allowEvents;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Return TRUE if no events are allowed\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  NoEventsAllowed(): boolean {\r\n    return this._allowEvents === EventsAllowedType.NONE;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check and execute control modify event\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <param name = \"act\"></param>\r\n  private async handleCtrlModify(ctrl: MgControl, act: number): Promise<void> {\r\n    // if cannot modify, do nothing\r\n    if (ctrl == null || !ctrl.isModifiable())\r\n      return;\r\n\r\n    switch (act) {\r\n      case InternalInterface.MG_ACT_RT_EDT_NULL:\r\n      case InternalInterface.MG_ACT_CTRL_MODIFY:\r\n      case InternalInterface.MG_ACT_SELECTION:\r\n        break;\r\n\r\n      default:\r\n        return;\r\n    }\r\n\r\n    let rtEvt: RunTimeEvent;\r\n    rtEvt = new RunTimeEvent(ctrl);\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_MODIFY);\r\n    await this.handleEvent(rtEvt, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if action is allowed according to the AllowedEvents flag\r\n  /// </summary>\r\n  /// <param name = \"act\"></param>\r\n  private ActAllowed(act: number): boolean {\r\n    let allowed: boolean = true;\r\n    switch (this.getAllowEvents()) {\r\n      case EventsAllowedType.ALL:\r\n        allowed = true;\r\n        break;\r\n\r\n      case EventsAllowedType.NONE:\r\n        // allow creline even in allow=no. we have no choice. RC mechanism is different then batch. it uses ACT_CREALINE\r\n        // when in create mode. We will need to change it in the future so that when user raises creline event it will not work. just internally.\r\n        allowed = (act === InternalInterface.MG_ACT_CRELINE);\r\n        break;\r\n\r\n      // Only the following actions are allowed when running inside a non interactive loop when allow events = YES.\r\n      case EventsAllowedType.NON_INTERACTIVE:\r\n\r\n        switch (act) {\r\n          case InternalInterface.MG_ACT_EXIT_SYSTEM:\r\n          case InternalInterface.MG_ACT_EXIT:\r\n          case InternalInterface.MG_ACT_CLOSE:\r\n          case InternalInterface.MG_ACT_CRELINE:\r\n          case InternalInterface.MG_ACT_CRELINE_ABOVE:\r\n          case InternalInterface.MG_ACT_ROLLBACK:\r\n            allowed = true;\r\n            break;\r\n\r\n          default:\r\n            allowed = false;\r\n            break;\r\n        }\r\n        break;\r\n    }\r\n\r\n    return allowed;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   This function commits the record and then depending on the success or failure of transaction, it performs other actions.\r\n  /// </summary>\r\n  /// <param name = \"task\"></param>\r\n  /// <param name = \"isReversibleExit\"></param>\r\n  private async commitRecord(task: Task, isReversibleExit: boolean): Promise<void> {\r\n    let dv: DataView = <DataView>task.DataView;\r\n    let rec: Record = dv.getCurrRec();\r\n\r\n    let forceSuffix: boolean = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);\r\n    let isSelectionTable: boolean = await task.checkProp(PropInterface.PROP_TYPE_SELECTION, false);\r\n    let isNewRec: boolean = rec.isNewRec();\r\n    let savePrevCurrRec: boolean = true;\r\n    let recModified: boolean = rec.Modified;\r\n\r\n    if (!dv.recInModifiedTab(rec.getId()))\r\n      rec.clearFlagsHistory();\r\n    await task.TaskTransactionManager.checkAndCommit(isReversibleExit, ConstInterface.TRANS_RECORD_PREFIX, task.ConfirmUpdateNo);\r\n    if (task.transactionFailed(ConstInterface.TRANS_RECORD_PREFIX)) {\r\n      // on failure of the transaction reenter the record level by\r\n      // executing \"record prefix\" for the subforms which executed\r\n      // the suffix successfully\r\n      try {\r\n        task.DataSynced = true;\r\n        this.setStopExecution(false);\r\n        await task.handleEventOnSlaveTasks(InternalInterface.MG_ACT_REC_PREFIX);\r\n      } finally {\r\n        this.setStopExecution(true);\r\n      }\r\n    } else if (task.isAborting())\r\n      this.setStopExecution(true);\r\n    else {\r\n      if (recModified)\r\n        rec.setLateCompute(true);\r\n\r\n      // QCR 783071 if after checkAndCommit all if O.K. the\r\n      // return the level back to task level in order to let rec_prfix to be executed.\r\n      // even though the task level should be TASK_LEVEL_TASK\r\n      // the checkAndCommit process could have change it\r\n      if (!this._stopExecution)\r\n        task.setLevel(Constants.TASK_LEVEL_TASK);\r\n\r\n      rec.resetUpdated();\r\n      rec.resetModified();\r\n\r\n      // QCR #983178: cancel the record only after the transaction\r\n      // handling was completed successfully and the record wasn't\r\n      // modified\r\n      if (!recModified && !forceSuffix && (!isSelectionTable || !task.InSelect)) {\r\n        if (isNewRec) {\r\n          // QCR #428965: save the previous current record BEFORE\r\n          // \"cancel edit\" so the correct record is saved\r\n          dv.setPrevCurrRec();\r\n          savePrevCurrRec = false;\r\n          rec.setNewRec();\r\n          await (<MgForm>task.getForm()).cancelEdit(false, false);\r\n          await this.HandleStopRowEditing(task);\r\n        } else if (!rec.getForceSaveOrg())\r\n          await dv.cancelEdit(EventsManager.REAL_ONLY, true);\r\n        else\r\n          dv.saveOriginal();\r\n      }\r\n      // QCR #995222: if the record was modified then save the\r\n      // original record again in case a task lavel transaction\r\n      // will fail with retry strategy. Before this fix, if such\r\n      // thing happened on a record which wasn't the first then\r\n      // the \"begin table\" event raised a record suffix event and\r\n      // caused \"cancel edit\".\r\n      else\r\n        dv.saveOriginal();\r\n    }\r\n\r\n    if (savePrevCurrRec)\r\n      dv.setPrevCurrRec();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   callback for incremental locate timer\r\n  /// </summary>\r\n  incLocateTimerCB(taskObj: any): void {\r\n    let task: Task = taskObj;\r\n    let rtEvt: RunTimeEvent = new RunTimeEvent(task, true);\r\n\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_INCREMENTAL_LOCATE);\r\n    rtEvt.setMainPrgCreator(task);\r\n    rtEvt.setCtrl(<MgControl>task.getLastParkedCtrl());\r\n    this.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"task\"></param>\r\n  /// <returns></returns>\r\n  private static async doSyncForSubformParent(task: Task): Promise<void> {\r\n\r\n    let parentTask: Task = <Task>task.getParent();\r\n    let parentDv = <DataView>parentTask.DataView;\r\n    let parentRec: Record = parentDv.getCurrRec();\r\n\r\n    // do not touch the parent record if the parent dataview is 'empty dataview'.\r\n    if (task.IsSubForm && parentRec != null && parentRec.Modified && !parentDv.isEmptyDataview()) {\r\n      parentRec.setMode(DataModificationTypes.Update);\r\n      await parentDv.addCurrToModified(false);\r\n      ((parentDv.getCurrRec())).Synced = true;\r\n      parentDv.setChanged(true);\r\n      let dataViewExecuteLocalUpdatesCommand: IClientCommand = CommandFactory.CreateDataViewCommand(parentTask.getTaskTag(), DataViewCommandType.ExecuteLocalUpdates);\r\n      await parentTask.DataviewManager.Execute(dataViewExecuteLocalUpdatesCommand);\r\n    }\r\n  }\r\n\r\n  async ProcessAbortingError(ex: ApplicationException): Promise<void> {\r\n    let eMsg: string;\r\n    let errForConsole: string;\r\n    let errForMsgBox: string;\r\n\r\n    if (ex instanceof ServerError)\r\n      eMsg = (<ServerError>ex).GetMessage();\r\n    else\r\n      eMsg = ((ex.Message !== null) ? ex.Message : ex.GetType());\r\n\r\n    errForConsole = StrUtil.getConsoleErorString(eMsg);\r\n    errForMsgBox = StrUtil.getMsgBoxErorString(eMsg);\r\n\r\n    if (ex.InnerException !== null)\r\n      Logger.Instance.WriteExceptionToLog(ex.InnerException, errForConsole);\r\n    else {\r\n      if (!(ex instanceof ServerError) || Logger.Instance.LogLevel !== Logger_LogLevels.Basic) {\r\n        Logger.Instance.WriteExceptionToLogWithMsg(errForConsole);\r\n      }\r\n    }\r\n\r\n    // TODO : handle errors\r\n    let sendUnloadToServer: boolean = RuntimeContextBase.Instance.ContextID !== RuntimeContextBase.noContextId;  // unload the context in the server only if a context was created during the current session\r\n\r\n    MGDataCollection.Instance.currMgdID = 0;\r\n\r\n    let messageString: string = LanguageData.Instance.getConstMessage(MsgInterface.BRKTAB_STR_ERROR);\r\n\r\n    let style: number = 16;\r\n    if (ex.Message.startsWith('<HTML')) {\r\n      this.processHTMLContent(ex.Message);\r\n    } else {\r\n      // TODO: temporarily show the message box\r\n      // ideally, the current page should be replaced with the error page\r\n      if (this.ShowErrorInMessageBox(ex)) {\r\n        await GUIManager.Instance.MessageBox(messageString, errForMsgBox, style);\r\n      }\r\n      if (ex instanceof ServerError){\r\n        if((<ServerError>ex).GetCode() == ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED ||\r\n           (<ServerError>ex).GetCode() == ServerError.ERR_EXECUTED_PROGRAM_CHANGED) {\r\n           Commands.addGlobalCommand(CommandType.RELOAD_PAGE);\r\n           // Must call beginInvoke here; in the case a new connection was refused, the beginInvoke is never called, so we\r\n           // need to make sure it is called here\r\n           Commands.beginInvoke();\r\n        }\r\n      }\r\n    }\r\n\r\n    // TODO: How to check if it was ConnectFailure or ProtocolError?\r\n    // In case if we are able to connect to the server i.e. status is ConnectionFailure\r\n    // then there is no point in sending unload command, because it will never succeed and\r\n    // we will in infinite loop.\r\n    // let flag8: boolean = ex.InnerException !== null && ex.InnerException.GetType().FullName === \"System.Net.WebException\";\r\n    // if (flag8) {\r\n    //   let ex2: WebException = <WebException>ex.InnerException;\r\n    //   let flag9: boolean = ex2.Status === WebExceptionStatus.ConnectFailure || ex2.Status === WebExceptionStatus.ProtocolError;\r\n    //   if (flag9) {\r\n    //     sendUnloadToServer = false;\r\n    //   }\r\n    // }\r\n\r\n    if (ex instanceof ServerError) {\r\n      // If the context was not found, or the program is reloaded by the server, no point in trying to unload it\r\n      if ((<ServerError>ex).GetCode() === ServerError.ERR_CTX_NOT_FOUND ||\r\n          (<ServerError>ex).GetCode() === ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED ||\r\n          (<ServerError>ex).GetCode() === ServerError.ERR_EXECUTED_PROGRAM_CHANGED) {\r\n        sendUnloadToServer = false;\r\n      }\r\n    }\r\n\r\n    if (sendUnloadToServer) {\r\n      // tell the server to close the runtime.\r\n      // If we terminate RTE and then close RC window then also we will be\r\n      // Processing Abort error in that case server is already closed so catch the exception.\r\n      try {\r\n        let cmd: IClientCommand = CommandFactory.CreateUnloadCommand();\r\n        MGDataCollection.Instance.getMGData(0).CmdsToServer.Add(cmd);\r\n        await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n      } catch (ex3) {\r\n        if (ex3 instanceof ApplicationException) {\r\n          Logger.Instance.WriteExceptionToLog(ex3);\r\n        } else\r\n          throw ex3;\r\n      }\r\n    }\r\n\r\n    GUIManager.Instance.abort();\r\n  }\r\n\r\n\r\n  processHTMLContent(htmlContent: string): void {\r\n    Commands.addShowHTMLError(CommandType.SHOW_HTML_ERROR, htmlContent);\r\n    Commands.beginInvoke();\r\n  }\r\n\r\n  // This method decides if the error handled in ProcessAbortingError will open a message box\r\n  ShowErrorInMessageBox(ex: ApplicationException): boolean {\r\n    if(!(ex instanceof ServerError))\r\n      return true;\r\n\r\n    // if changes in the studio cause a reload, show the messagebox only if the user tried to\r\n    // continue working with an old context\r\n    if(((<ServerError>ex).GetCode() == ServerError.ERR_EXECUTED_PROGRAM_CHANGED ||\r\n       (<ServerError>ex).GetCode() == ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED) &&\r\n        RuntimeContextBase.Instance.ContextID === RuntimeContextBase.noContextId)\r\n      return false;\r\n\r\n    return true;\r\n  }\r\n\r\n  getIsInViewRefresh(): boolean{\r\n    return this.isInViewRefresh;\r\n  }\r\n\r\n  setIsInViewRefresh(inViewRefresh: boolean): void{\r\n    this.isInViewRefresh = inViewRefresh;\r\n  }\r\n}\r\n"]}