@magic-xpa/engine 4.1100.0-dev4110.2 → 4.1100.0-dev4110.202

package/esm2022/src/gui/MgForm.mjs

@@ -0,0 +1,1181 @@
+import { Commands, CommandType, DataModificationTypes, GuiEnvironment, Manager, MgFormBase, PropInterface } from '@magic-xpa/gui';
+import { Constants, InternalInterface, Logger, MgControlType, Misc, Priority, XMLConstants } from '@magic-xpa/utils';
+import { ApplicationException, Debug, Exception, Int32, NString, RefParam, StringBuilder } from '@magic-xpa/mscorelib';
+import { MgControl } from './MgControl';
+import { RecordOutOfDataViewException } from '../data/RecordOutOfDataViewException';
+import { SET_DISPLAYLINE_BY_DV } from '../data/DataView';
+import { TaskBase } from '../tasks/TaskBase';
+import { ServerError } from '../remote/ServerError';
+import { ConstInterface } from '../ConstInterface';
+import { LastFocusedManager } from '../rt/LastFocusedManager';
+import { CreatedFormVector } from './CreatedFormVector';
+import { AccessHelper } from '../AccessHelper';
+export class MgForm extends MgFormBase {
+    static TIME_LIMIT = 50;
+    IsMovingInView = false;
+    PrevDisplayLine = 0;
+    RefreshAllRows = false;
+    IgnoreFirstRecordCycle = false;
+    MovedToFirstControl = false;
+    _suffixDone = false;
+    hiddenControlsIsnsList = null;
+    static _createdForms = new CreatedFormVector();
+    _transferringDataToGUI = false;
+    isFetchingRecordsAhead = false;
+    constructor() {
+        super();
+    }
+    static get CreatedForms() {
+        return MgForm._createdForms;
+    }
+    get InRestore() {
+        return this._inRestore;
+    }
+    get TransferringDataToGUI() {
+        return this._transferringDataToGUI;
+    }
+    get shouldFetchRecordsAheadFromServer() {
+        if (this.isTableWithPagination()) {
+            let prop = this._tableMgControl.GetComputedProperty(PropInterface.PROP_TYPE_SERVER_READ_AHEAD);
+            return (prop != null ? prop.GetComputedValueBoolean() : false);
+        }
+        else
+            return false;
+    }
+    async FetchRecordsAheadFromServer() {
+        this.isFetchingRecordsAhead = true;
+        await this.GetDataview().FetchRecordsAheadFromServer();
+        this.isFetchingRecordsAhead = false;
+    }
+    GetDataview() {
+        let dv = null;
+        if (this._task != null)
+            dv = this._task.DataView;
+        return (dv);
+    }
+    async moveInView(unit, direction) {
+        let oldRecId = Int32.MinValue;
+        let currRec = this.GetDataview().getCurrRec();
+        let oldTaskMode = ' ';
+        let returnToVisibleLine = false;
+        let recordOutOfView = false;
+        let visibleLine = 0;
+        try {
+            this.IsMovingInView = true;
+            let oldDisplayLine = this.DisplayLine;
+            if (unit === Constants.MOVE_UNIT_TABLE) {
+                try {
+                    if (direction === Constants.MOVE_DIRECTION_BEGIN) {
+                        await this.GetDataview().setCurrRecByIdx(Constants.MG_DATAVIEW_FIRST_RECORD, true, false, true, SET_DISPLAYLINE_BY_DV);
+                        if (this.isLineMode()) {
+                            this.GetDataview().setTopRecIdx(0);
+                            await this.setCurrRowByDisplayLine(0, false, false);
+                        }
+                    }
+                    else {
+                        await this.GetDataview().setCurrRecByIdx(Constants.MG_DATAVIEW_LAST_RECORD, true, false, true, SET_DISPLAYLINE_BY_DV);
+                        if (this.isLineMode()) {
+                            this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx() - this._rowsInPage + 1);
+                            if (this.GetDataview().getTopRecIdx() >= 0)
+                                await this.setCurrRowByDisplayLine(this.GetDataview().getCurrRecIdx(), false, false);
+                            else {
+                                this.GetDataview().setTopRecIdx(0);
+                                await this.setCurrRowByDisplayLine(this.GetDataview().getCurrRecIdx(), false, false);
+                            }
+                        }
+                    }
+                    this.updateDisplayLineByDV();
+                    await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                }
+                catch (ex) {
+                    if (ex instanceof RecordOutOfDataViewException)
+                        Logger.Instance.WriteDevToLog(ex.Message);
+                }
+            }
+            else {
+                this.getTopIndexFromGUI();
+                let size;
+                if (unit === Constants.MOVE_UNIT_PAGE && this.isLineMode()) {
+                    switch (direction) {
+                        case Constants.MOVE_DIRECTION_BEGIN:
+                            size = this.GetDataview().getCurrRecIdx() - this.GetDataview().getTopRecIdx();
+                            break;
+                        case Constants.MOVE_DIRECTION_END:
+                            let last = this.GetDataview().getTopRecIdx() + this._rowsInPage - 1;
+                            last = Math.min(last, this.GetDataview().getSize() - 1);
+                            size = last - this.GetDataview().getCurrRecIdx();
+                            break;
+                        default:
+                            returnToVisibleLine = true;
+                            size = this._rowsInPage;
+                            break;
+                    }
+                }
+                else
+                    size = 1;
+                size = (direction === Constants.MOVE_DIRECTION_PREV ||
+                    direction === Constants.MOVE_DIRECTION_BEGIN
+                    ? -size
+                    : size);
+                if (this.isLineMode()) {
+                    visibleLine = this.getVisibleLine();
+                    if (visibleLine < 0) {
+                        visibleLine = 0;
+                        recordOutOfView = true;
+                    }
+                    if (visibleLine > this._rowsInPage + 1) {
+                        visibleLine = this._rowsInPage;
+                        recordOutOfView = true;
+                    }
+                    if (unit === Constants.MOVE_UNIT_PAGE &&
+                        (direction === Constants.MOVE_DIRECTION_NEXT ||
+                            direction === Constants.MOVE_DIRECTION_PREV) ||
+                        unit === Constants.MOVE_UNIT_ROW &&
+                            (direction === Constants.MOVE_DIRECTION_NEXT && visibleLine === this._rowsInPage - 1 ||
+                                direction === Constants.MOVE_DIRECTION_PREV && visibleLine === 0)) {
+                        if (direction === Constants.MOVE_DIRECTION_PREV &&
+                            (unit === Constants.MOVE_UNIT_ROW || unit === Constants.MOVE_UNIT_PAGE) &&
+                            visibleLine === 0 && this.GetDataview().getCurrRecIdx() === 0 && this.GetDataview().IncludesFirst())
+                            return;
+                        if (direction === Constants.MOVE_DIRECTION_NEXT && unit === Constants.MOVE_UNIT_PAGE &&
+                            visibleLine === this.getLastValidRow() && this.GetDataview().getCurrRecIdx() === this.GetDataview().getSize() - 1 && this.GetDataview().IncludesLast())
+                            return;
+                        oldRecId = (this.GetDataview().getCurrRec()).getId();
+                        this.GetDataview().setTopRecIdx(this.GetDataview().getTopRecIdx() + size);
+                        this.GetDataview().setTopRecIdxModified(true);
+                        try {
+                            this._suffixDone = false;
+                            await this.setCurrRowByDisplayLine(this.GetDataview().getCurrRecIdx() + size, true, false);
+                            this.GetDataview().setTopRecIdxModified(false);
+                            await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                        }
+                        catch (ex) {
+                            if (ex instanceof RecordOutOfDataViewException) {
+                                this.GetDataview().setTopRecIdxModified(false);
+                                if (AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                                    this.GetDataview().restoreTopRecIdx();
+                                    await this.restoreOldDisplayLine(oldDisplayLine);
+                                    return;
+                                }
+                                if (this.GetDataview().getTopRecIdx() < 0) {
+                                    this.GetDataview().setTopRecIdx(0);
+                                    try {
+                                        await this.setCurrRowByDisplayLine(0, true, false);
+                                    }
+                                    catch (exception) {
+                                        if (exception instanceof Exception) {
+                                            if (AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                                                this.GetDataview().restoreTopRecIdx();
+                                                await this.restoreOldDisplayLine(oldDisplayLine);
+                                                return;
+                                            }
+                                        }
+                                    }
+                                    await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                                }
+                                else if (unit !== Constants.MOVE_UNIT_ROW && this.GetDataview().recExists(this.GetDataview().getTopRecIdx())) {
+                                    let newRecId = (this.GetDataview().getCurrRec()).getId();
+                                    if (newRecId === oldRecId && !this._suffixDone) {
+                                        await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_SUFFIX);
+                                        if (AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                                            this.GetDataview().restoreTopRecIdx();
+                                            await this.restoreOldDisplayLine(oldDisplayLine);
+                                            return;
+                                        }
+                                        try {
+                                            await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                                            await this.setCurrRowByDisplayLine(this.GetDataview().getTopRecIdx() + this.getLastValidRow(), false, true);
+                                            visibleLine = this.getLastValidRow();
+                                        }
+                                        catch (Exception) {
+                                        }
+                                    }
+                                }
+                                else {
+                                    this.GetDataview().restoreTopRecIdx();
+                                    await this.restoreOldDisplayLine(oldDisplayLine);
+                                    if (unit === Constants.MOVE_UNIT_ROW && direction === Constants.MOVE_DIRECTION_NEXT) {
+                                        if (!this._task.IsInteractive && this._task.getMode() !== Constants.TASK_MODE_CREATE)
+                                            this._task.setExecEndTask();
+                                        else
+                                            await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);
+                                    }
+                                    return;
+                                }
+                                Logger.Instance.WriteDevToLog(ex.Message);
+                            }
+                        }
+                    }
+                    else {
+                        try {
+                            oldTaskMode = this._task.getMode();
+                            oldRecId = (this.GetDataview().getCurrRec()).getId();
+                            await this.setCurrRowByDisplayLine(oldDisplayLine + size, true, false);
+                            if (!this.GetDataview().recExistsById(oldRecId)) {
+                                if (size > 0 || oldTaskMode !== Constants.TASK_MODE_CREATE)
+                                    if (size !== -1 || this.GetDataview().recExists(oldDisplayLine))
+                                        await this.setCurrRowByDisplayLine(oldDisplayLine, false, false);
+                                    else
+                                        Logger.Instance.WriteDevToLog(NString.Format("skipped setcurrRow for row {0}", oldDisplayLine));
+                                await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                            }
+                            else if (AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                                await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                            }
+                        }
+                        catch (ex) {
+                            if (ex instanceof RecordOutOfDataViewException) {
+                                if (this.GetDataview().recExistsById(oldRecId)) {
+                                    await this.restoreOldDisplayLine(oldDisplayLine);
+                                    if (!currRec.Synced && oldTaskMode === Constants.TASK_MODE_CREATE) {
+                                        this._task.setMode(Constants.TASK_MODE_CREATE);
+                                        currRec.clearMode();
+                                        currRec.setMode(DataModificationTypes.Insert);
+                                        currRec.setNewRec();
+                                    }
+                                    await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+                                }
+                                else {
+                                    if (oldTaskMode === Constants.TASK_MODE_CREATE && oldDisplayLine > 0)
+                                        await this.restoreOldDisplayLine(oldDisplayLine - 1);
+                                    await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                                }
+                                if (size <= 0 || AccessHelper.eventsManager.GetStopExecutionFlag())
+                                    Logger.Instance.WriteDevToLog(ex.Message);
+                                else {
+                                    if (!this._task.IsInteractive && this._task.getMode() !== Constants.TASK_MODE_CREATE) {
+                                        this._task.setExecEndTask();
+                                        return;
+                                    }
+                                    else {
+                                        if (this._task.ActionManager.isEnabled(InternalInterface.MG_ACT_CRELINE))
+                                            await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);
+                                        else {
+                                            let doRecordSuffix = true;
+                                            let refdoRecordSuffix = new RefParam(doRecordSuffix);
+                                            if (!await AccessHelper.eventsManager.DoTaskLevelRecordSuffix(this._task, refdoRecordSuffix))
+                                                await AccessHelper.eventsManager.DoTaskLevelRecordPrefix(this._task);
+                                            doRecordSuffix = refdoRecordSuffix.value;
+                                        }
+                                    }
+                                }
+                                return;
+                            }
+                        }
+                    }
+                }
+                else {
+                    try {
+                        await this.GetDataview().setCurrRecByIdx(this.GetDataview().getCurrRecIdx() + size, true, false, true, SET_DISPLAYLINE_BY_DV);
+                        await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                    }
+                    catch (ex) {
+                        if (ex instanceof RecordOutOfDataViewException) {
+                            if (size > 0) {
+                                if (!this._task.IsInteractive && this._task.getMode() !== Constants.TASK_MODE_CREATE)
+                                    this._task.setExecEndTask();
+                                else
+                                    await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);
+                            }
+                            else
+                                Logger.Instance.WriteDevToLog(ex.Message);
+                            return;
+                        }
+                        else if (ex instanceof ServerError) {
+                            await this._task.stop();
+                            this._task.abort();
+                            await AccessHelper.eventsManager.ProcessAbortingError(ex);
+                        }
+                        else if (ex instanceof Exception) {
+                            Logger.Instance.WriteDevToLog(ex.Message);
+                            return;
+                        }
+                    }
+                }
+            }
+            if (returnToVisibleLine) {
+                if (recordOutOfView) {
+                    if (visibleLine === 0)
+                        this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx());
+                    else
+                        this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx() - this._rowsInPage);
+                    this.SetTableTopIndex();
+                }
+                else {
+                    this.SetTableTopIndex();
+                    await this.setCurrRowByDisplayLine(this.GetDataview().getTopRecIdx() + visibleLine, false, true);
+                }
+            }
+            else
+                this.SetTableTopIndex();
+            await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_PREFIX);
+        }
+        catch (e) {
+            if (e instanceof RecordOutOfDataViewException) {
+                Logger.Instance.WriteDevToLog(e.Message);
+            }
+        }
+        finally {
+            this.SelectRow();
+            this.IsMovingInView = false;
+        }
+    }
+    async addRec(doSuffix, isCrelineAbove) {
+        let newLine = 1;
+        let currLine = -1;
+        if (!this._task.DataView.isEmptyDataview())
+            currLine = this.getVisibleLine();
+        if (this.isTableWithAbsoluteScrollbar()) {
+            this.GetDataview().TotalRecordsCount += 1;
+            this.RefreshAllRows = true;
+        }
+        let newRecIdx = await this.GetDataview().addRecord(doSuffix, false, isCrelineAbove);
+        if (newRecIdx > -1) {
+            if (this.isLineMode()) {
+                let newCurrRow;
+                if (this.GetDataview().getSize() === 0 || this.GetDataview().getTopRecIdx() === Int32.MinValue) {
+                    this.GetDataview().setTopRecIdx(0);
+                    newCurrRow = 0;
+                }
+                else if (currLine === this._rowsInPage - 1) {
+                    this.GetDataview().setTopRecIdx(this.GetDataview().getTopRecIdx() + 1);
+                    newCurrRow = this.getVisibleLine();
+                }
+                else {
+                    if (isCrelineAbove)
+                        newCurrRow = currLine > 0 ? currLine : 0;
+                    else
+                        newCurrRow = currLine + 1;
+                }
+                newLine = this.GetDataview().getTopRecIdx() + newCurrRow;
+                this.removeRecordsAfterIdx(this.GetDataview().getTopRecIdx() + newCurrRow);
+                try {
+                    if (!this._task.DataView.isEmptyDataview())
+                        this._task.setMode(Constants.TASK_MODE_CREATE);
+                    await this.setCurrRowByDisplayLine(newLine, false, false);
+                }
+                catch (ex) {
+                    if (ex instanceof RecordOutOfDataViewException) {
+                        Logger.Instance.WriteDevToLog(NString.Format("in Form.addRec() {0}", ex.Message));
+                    }
+                }
+                await this.RefreshDisplay(Constants.TASK_REFRESH_TABLE);
+            }
+        }
+        else if (this.isTableWithAbsoluteScrollbar()) {
+            this.GetDataview().TotalRecordsCount -= 1;
+            this.RefreshAllRows = false;
+        }
+    }
+    async delCurrRec() {
+        let topTableRow = super.isLineMode() && this.GetDataview().getTopRecIdx() === this.GetDataview().getCurrRecIdx();
+        await this.GetDataview().removeCurrRec();
+        if (this.GetDataview().isEmpty() && !this._task.IsTryingToStop) {
+            if (this._task.DataView.isEmptyDataview()) {
+                await this.addRec(false, false);
+            }
+            else {
+                if (await this._task.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true)) {
+                    if (this._task.getMode() !== Constants.TASK_MODE_CREATE)
+                        this._task.setMode(Constants.TASK_MODE_CREATE);
+                    this._task.enableCreateActs(true);
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);
+                }
+                else
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_EXIT);
+            }
+        }
+        if (!this.GetDataview().isEmpty()) {
+            if (topTableRow)
+                this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx());
+            if (super.isLineMode()) {
+                if (super.HasTable()) {
+                    if (this.isTableWithAbsoluteScrollbar()) {
+                        this.GetDataview().TotalRecordsCount--;
+                        this.RefreshAllRows = true;
+                    }
+                    this.removeRecordsAfterIdx(this.GetDataview().getCurrRecIdx());
+                    await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                }
+                else
+                    await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+            }
+            else {
+                try {
+                    await this.GetDataview().setCurrRecByIdx(this.GetDataview().getCurrRecIdx(), true, true, true, SET_DISPLAYLINE_BY_DV);
+                }
+                catch (ex) {
+                    if (ex instanceof RecordOutOfDataViewException) {
+                    }
+                    else
+                        throw ex;
+                }
+                await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+            }
+        }
+    }
+    async cancelEdit(isActCancel, isQuitEvent) {
+        let mode = this._task.getMode();
+        let newMode;
+        let row = 0;
+        let execRecPrefix = false;
+        if (this.GetDataview().getSize() === 1 && mode === Constants.TASK_MODE_CREATE)
+            newMode = Constants.TASK_MODE_CREATE;
+        else
+            newMode = Constants.TASK_MODE_MODIFY;
+        let recRemoved = await this.GetDataview().cancelEdit(false, false);
+        this.GetDataview().setPrevCurrRec(null);
+        if ((this.GetDataview().isEmpty() || ((isActCancel && recRemoved) && (!GuiEnvironment.Environment.GetSpecialCancelOnCreate()) && this._task.getOriginalTaskMode() === Constants.TASK_MODE_CREATE)) && !this._task.IsTryingToStop) {
+            let orgCancelWasRaised = this._task.cancelWasRaised();
+            this._task.setCancelWasRaised(isActCancel);
+            await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);
+            this._task.setCancelWasRaised(orgCancelWasRaised);
+        }
+        else if (isActCancel)
+            execRecPrefix = true;
+        if (!this.GetDataview().isEmpty()) {
+            if (super.isLineMode()) {
+                try {
+                    if (super.HasTable()) {
+                        row = this.getVisibleLine();
+                        if (row < 0 || row >= this._rowsInPage) {
+                            let topRecIdx = this.GetDataview().getTopRecIdx();
+                            let currRecIdx = this.GetDataview().getCurrRecIdx();
+                            if (topRecIdx > currRecIdx)
+                                this.GetDataview().setTopRecIdx(currRecIdx);
+                            row = 0;
+                        }
+                        await this.setCurrRowByDisplayLine(this.GetDataview().getTopRecIdx() + row, false, true);
+                    }
+                }
+                catch (ex) {
+                    if (ex instanceof RecordOutOfDataViewException) {
+                        if (row !== 0)
+                            Logger.Instance.WriteDevToLog(NString.Format("in Form.cancelEdit() {0}", ex.Message));
+                    }
+                    else
+                        throw ex;
+                }
+                if (super.HasTable()) {
+                    if (this.isTableWithAbsoluteScrollbar() && recRemoved) {
+                        this.GetDataview().TotalRecordsCount--;
+                        this.RefreshAllRows = true;
+                    }
+                    this.removeRecordsAfterIdx(this.GetDataview().getCurrRecIdx());
+                }
+            }
+            else {
+                try {
+                    await this.GetDataview().setCurrRecByIdx(this.GetDataview().getCurrRecIdx(), false, true, true, SET_DISPLAYLINE_BY_DV);
+                }
+                catch (ex) {
+                    if (ex instanceof RecordOutOfDataViewException) {
+                        Logger.Instance.WriteDevToLog("in Form.cancelEdit() error in Screen mode for Current Record");
+                    }
+                    else
+                        throw ex;
+                }
+            }
+            this._task.setMode(newMode);
+            if (!this._task.InEndTask)
+                await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+            if (!this._task.InEndTask)
+                await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+        }
+        if (execRecPrefix) {
+            this._task.setLevel(Constants.TASK_LEVEL_TASK);
+            let lastParkedCtrl = LastFocusedManager.getLastFocusedControl();
+            if (lastParkedCtrl !== null) {
+                if (lastParkedCtrl.getForm().getTask().pathContains(this._task))
+                    for (let parent = lastParkedCtrl.getForm().getTask(); parent !== null && parent !== this._task; parent = parent.getParent()) {
+                        parent.setLevel(Constants.TASK_LEVEL_TASK);
+                        (parent.DataView.getCurrRec()).resetModified();
+                    }
+                else
+                    lastParkedCtrl.getForm().getTask().setLevel(Constants.TASK_LEVEL_TASK);
+            }
+            if (!isQuitEvent) {
+                await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_PREFIX);
+                await AccessHelper.eventsManager.HandleParkabilityOnRowChange(this._task);
+            }
+        }
+    }
+    async refreshOnExpressions() {
+        for (let i = 0; i < this.CtrlTab.getSize(); i = i + 1) {
+            let mgControl = ((this.CtrlTab.getCtrl(i) instanceof MgControl) ? this.CtrlTab.getCtrl(i) : null);
+            if (mgControl != null)
+                await mgControl.refreshOnExpression();
+            else
+                Debug.Assert(false);
+        }
+        await super.refreshPropsOnExpression();
+    }
+    removeRefsToCtrls() {
+        let lastFocusedControl = LastFocusedManager.getLastFocusedControl();
+        if (lastFocusedControl !== null && lastFocusedControl.getForm() === this)
+            LastFocusedManager.setLastFocusedControl(this._task, null);
+        super.removeRefsToCtrls();
+    }
+    getCtrlByCtrlName(ctrlName) {
+        return this.CtrlTab.getCtrl(ctrlName);
+    }
+    getSubFormCtrlByName(ctrlName) {
+        let guiParentTask;
+        let destSubForm = null;
+        for (guiParentTask = this._task; destSubForm === null && guiParentTask !== null && guiParentTask.getForm() !== null; guiParentTask = guiParentTask.getParent()) {
+            destSubForm = guiParentTask.getForm().getCtrlByName(ctrlName, MgControlType.CTRL_TYPE_SUBFORM);
+            if (destSubForm == null) {
+                if (!guiParentTask.IsSubForm || NString.Equals(guiParentTask.getForm().getSubFormCtrl().Name, ctrlName, true))
+                    break;
+            }
+        }
+        return destSubForm;
+    }
+    setSuffixDone() {
+        this._suffixDone = true;
+    }
+    getDestinationRow() {
+        return this._destTblRow;
+    }
+    setSubFormCtrl(subFormCtrl) {
+        Debug.Assert(this._subFormCtrl === null && subFormCtrl !== null);
+        this._subFormCtrl = subFormCtrl;
+    }
+    getSubFormCtrlForTask(taskId) {
+        let curr = null;
+        let parentCtrlTab;
+        let guiParentForm = null;
+        let destSubForm = null;
+        for (guiParentForm = this; guiParentForm != null; guiParentForm = guiParentForm.ParentForm) {
+            parentCtrlTab = guiParentForm.CtrlTab;
+            for (let i = 0; i < parentCtrlTab.getSize(); i++) {
+                curr = ((parentCtrlTab.getCtrl(i) instanceof MgControl) ? parentCtrlTab.getCtrl(i) : null);
+                if (curr != null && curr.isSubform() && (curr.getSubformTaskId() != null))
+                    if (curr.getSubformTaskId() === taskId) {
+                        destSubForm = curr;
+                        break;
+                    }
+            }
+            if (destSubForm != null)
+                break;
+        }
+        return destSubForm;
+    }
+    removeRecordsAfterIdx(idx) {
+        let removeAll = false;
+        if (this.isTableWithPagination())
+            this.setTableItemsCount(false);
+        else {
+            if (idx <= this._rowsInPage + 1 && this.GetDataview().getSize() > this._rowsInPage)
+                idx = 0;
+            if (idx === 0)
+                removeAll = true;
+            super.SetTableItemsCount(idx, removeAll);
+            this.setTableItemsCount(false);
+        }
+    }
+    isRowValidated(idx) {
+        if (this.Rows.length <= idx || idx < 0)
+            return false;
+        let row = this.Rows.get_Item(idx);
+        if (row == null)
+            return false;
+        return row.Created && row.Validated;
+    }
+    async transferDataToGui() {
+        let saveRowIdx = this.GetDataview().getCurrRecIdx();
+        let maxTime = Misc.getSystemMilliseconds() + MgForm.TIME_LIMIT;
+        let updated = false;
+        let currentEditingControl = super.getTask().CurrentEditingControl;
+        try {
+            let bkpRecord = this.GetDataview().backupCurrent();
+            while (Misc.getSystemMilliseconds() < maxTime && this.RefreshRepeatableAllowed) {
+                if (this._lastRowSent + 1 >= this.GetDataview().getSize()) {
+                    this.RefreshUI();
+                    break;
+                }
+                else if (this.isTableWithPagination() && this._lastRowSent + 1 >= this.getMaxRowsInPaginatedTable()) {
+                    this.RefreshUI();
+                    break;
+                }
+                this._lastRowSent++;
+                this._transferringDataToGUI = true;
+                this.AllowedSubformRecompute = false;
+                if (!this.isRowValidated(this._lastRowSent)) {
+                    super.checkAndCreateRow(this._lastRowSent);
+                    if (this._lastRowSent !== saveRowIdx) {
+                        super.getTask().CurrentEditingControl = null;
+                        await this.setCurrRowByDisplayLine(this._lastRowSent, false, true);
+                        await super.refreshControls(true);
+                        updated = true;
+                    }
+                }
+                this.AllowedSubformRecompute = true;
+                this._transferringDataToGUI = false;
+            }
+            if (updated) {
+                await this.restoreBackup(saveRowIdx, bkpRecord);
+                await super.refreshControls(true);
+                super.getTask().CurrentEditingControl = currentEditingControl;
+            }
+        }
+        catch (ex) {
+            if (ex instanceof RecordOutOfDataViewException) {
+                Logger.Instance.WriteDevToLog(ex.Message);
+            }
+            else
+                throw ex;
+        }
+        this._transferingData = false;
+        this.checkAndCreateRowsEvent();
+    }
+    checkAndCreateRowsEvent() {
+        if (this._tableMgControl !== null && this.Opened && this.RefreshRepeatableAllowed) {
+            let size = this.GetDataview().getSize();
+            if (this._lastRowSent >= this.Rows.length) {
+                this._lastRowSent = this.Rows.length - 1;
+            }
+            let transferDataToGui = this._lastRowSent < (size - 1);
+            if (this.isTableWithPagination() && (this._lastRowSent + 1) >= this.getMaxRowsInPaginatedTable())
+                transferDataToGui = false;
+            if (transferDataToGui && !this._transferingData) {
+                AccessHelper.eventsManager.addInternalEventWithCtrlAndCodeAndPriority(this._tableMgControl, InternalInterface.MG_ACT_DV_TO_GUI, Priority.LOWEST);
+                this._transferingData = true;
+            }
+            else if (this.shouldFetchRecordsAheadFromServer && !transferDataToGui && (!this.GetDataview().IncludesLast() || !this.GetDataview().IncludesFirst())) {
+                AccessHelper.eventsManager.addInternalEventWithCtrlAndCodeAndPriority(this._tableMgControl, InternalInterface.MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER, Priority.LOWEST);
+            }
+        }
+    }
+    async setRowData(desiredTopIndex, sendAll) {
+        let saveRowIdx = this.GetDataview().getCurrRecIdx();
+        let diff = 0;
+        let getPrevChunk = false;
+        let getNextChunk = false;
+        let updated = false;
+        if (desiredTopIndex !== Int32.MinValue) {
+            if (desiredTopIndex < 0) {
+                getPrevChunk = true;
+                this.GetDataview().setTopRecIdx(0);
+            }
+            else if (desiredTopIndex + this._rowsInPage + 1 >= this.GetDataview().getSize())
+                getNextChunk = true;
+        }
+        else
+            desiredTopIndex = this.GetDataview().getTopRecIdx();
+        let bkpRecord = this.GetDataview().backupCurrent();
+        this._transferringDataToGUI = true;
+        this.AllowedSubformRecompute = false;
+        let diffRef = new RefParam(diff);
+        updated = await this.refreshRows(desiredTopIndex, sendAll, saveRowIdx, diffRef);
+        diff = diffRef.value;
+        if ((getPrevChunk && diff !== 0) || getNextChunk) {
+            this.GetDataview().setTopRecIdx(desiredTopIndex + diff);
+            this.SetTableTopIndex();
+            if (this._topIndexUpdated) {
+                this._topIndexUpdated = false;
+            }
+        }
+        this.AllowedSubformRecompute = true;
+        this._transferringDataToGUI = false;
+        if (updated) {
+            await this.restoreBackup(saveRowIdx + diff, bkpRecord);
+            await super.refreshControls(true);
+        }
+        super.SelectRow();
+        if (getPrevChunk) {
+            let lastFocusedControl = LastFocusedManager.getLastFocusedControl();
+            if (lastFocusedControl !== null && lastFocusedControl.getParentTable() === this._tableMgControl) {
+            }
+        }
+    }
+    async refreshRows(desiredTopIndex, sendAll, saveRowIdx, diffRef) {
+        let index = 0;
+        let updated = false;
+        diffRef.value = 0;
+        let orgIncludesFirst = this.GetDataview().IncludesFirst();
+        let orgIncludesLast = this.GetDataview().IncludesLast();
+        for (let i = 0; i < this._rowsInPage; i++) {
+            let idx = desiredTopIndex + i;
+            let prevTopIdx = this.GetDataview().getTopRecIdx();
+            try {
+                index = idx + diffRef.value;
+                if (!this.isRowValidated(idx) || sendAll || this.RefreshAllRows) {
+                    if (index >= 0)
+                        super.checkAndCreateRow(index);
+                    if (saveRowIdx + diffRef.value !== index) {
+                        await this.setCurrRowByDisplayLine(index, false, true);
+                        await super.refreshControls(true);
+                    }
+                    updated = true;
+                }
+            }
+            catch (ex) {
+                if (ex instanceof RecordOutOfDataViewException) {
+                    if (super.isRowCreated(index))
+                        super.markRowNOTCreated(index);
+                    break;
+                }
+                else
+                    throw ex;
+            }
+            finally {
+                diffRef.value = diffRef.value + (this.GetDataview().getTopRecIdx() - prevTopIdx);
+                prevTopIdx = this.GetDataview().getTopRecIdx();
+                if (!updated && this.GetDataview().DataviewBoundriesAreChanged(orgIncludesFirst, orgIncludesLast))
+                    updated = true;
+            }
+        }
+        this.RefreshUI();
+        this.RefreshAllRows = false;
+        return updated;
+    }
+    getVisibleLine() {
+        let currRecIdx = 0;
+        if (this.GetDataview().getCurrRecIdx() !== Int32.MinValue)
+            currRecIdx = this.GetDataview().getCurrRecIdx();
+        return currRecIdx - Math.max(this.GetDataview().getTopRecIdx(), 0);
+    }
+    async bringRecordToPage() {
+        if (this._tableMgControl !== null && !this._task.DataView.isEmptyDataview()) {
+            let topIndex = Commands.getTopIndex(this._tableMgControl);
+            let currIdx = this.GetDataview().getCurrRecIdx();
+            let newTopIndex = topIndex;
+            if (!this.isTableWithPagination()) {
+                if (topIndex > currIdx) {
+                    this._topIndexUpdated = true;
+                    newTopIndex = currIdx;
+                }
+                else if (topIndex + this._rowsInPage - 1 < currIdx) {
+                    this._topIndexUpdated = true;
+                    if (this._rowsInPage > 0)
+                        newTopIndex = currIdx - this._rowsInPage + 1;
+                    else
+                        newTopIndex = currIdx;
+                }
+            }
+            else {
+                let currGuiIdx = this.getGuiRowidx(currIdx);
+                let newTopGuiIndex = (currGuiIdx) - ((currGuiIdx) % this._rowsInPage);
+                newTopIndex = this.getDvRowIdx(newTopGuiIndex);
+                if (newTopIndex !== this._prevGuiTopIndex || this.IsMovingInView)
+                    this._topIndexUpdated = true;
+            }
+            if (this.GetDataview().getTopRecIdx() !== newTopIndex || this._topIndexUpdated) {
+                this.GetDataview().setTopRecIdx(newTopIndex);
+                this.SetTableTopIndex();
+                await this.setRowData(Int32.MinValue, false);
+                this._topIndexUpdated = false;
+            }
+        }
+    }
+    invalidateTable() {
+        for (let i = 0; i < this.Rows.length; i++) {
+            let row = this.Rows.get_Item(i);
+            if (row !== null)
+                row.Validated = false;
+        }
+        this._lastRowSent = -1;
+        this.checkAndCreateRowsEvent();
+    }
+    getPrevLine(line) {
+        return line - 1;
+    }
+    clearTableColumnSortMark(clearSortMark) {
+        if (clearSortMark) {
+        }
+    }
+    async stopRowEditing(idx) {
+        if (this.getIsRowEditingFromGui(idx)) {
+            Commands.addValueWithLine(CommandType.SET_NOT_IS_ROW_EDITING, this, this.isLineMode() ? idx : 0, this.isLineMode());
+            await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+            Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());
+        }
+    }
+    async startRowEditing(idx) {
+        if (!this.getIsRowEditingFromGui(idx)) {
+            Commands.addValueWithLine(CommandType.SET_IS_ROW_EDITING, this, this.isLineMode() ? idx : 0, this.isLineMode());
+            await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+            Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());
+        }
+    }
+    getIsRowEditingFromGui(displayIndex) {
+        let isRowEditing = Commands.getIsRowEditing(this, this.isLineMode() ? displayIndex : 0, this.isLineMode());
+        return isRowEditing;
+    }
+    async RefreshDisplay(refreshType) {
+        let task = this._task;
+        if (this.isFetchingRecordsAhead)
+            return false;
+        if (task.isAborting())
+            return false;
+        let currRec = this.GetDataview().getCurrRec();
+        if (currRec !== null && currRec.InCompute && !currRec.isNewRec())
+            return false;
+        if (this._inRefreshDisp)
+            return false;
+        this._inRefreshDisp = true;
+        try {
+            if (refreshType === Constants.TASK_REFRESH_FORM || refreshType === Constants.TASK_REFRESH_TABLE) {
+                if (super.HasTable() && this.Opened)
+                    await this.refreshTable();
+            }
+            if (refreshType === Constants.TASK_REFRESH_FORM || refreshType === Constants.TASK_REFRESH_CURR_REC) {
+                if (refreshType === Constants.TASK_REFRESH_CURR_REC && super.hasTable()) {
+                    this.SetTableTopIndex();
+                    super.SelectRow();
+                    await this.fetchPrevChunkForCurrentPage();
+                }
+                await super.refreshProps();
+                await super.refreshControls(false);
+            }
+        }
+        catch (ex) {
+            if (ex instanceof Exception) {
+                Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("{0} : {1} in task {2}", ex.GetType(), ex.Message, super.getTask().PreviouslyActiveTaskId));
+            }
+            else
+                throw ex;
+        }
+        finally {
+            this._inRefreshDisp = false;
+        }
+        if (refreshType === Constants.TASK_REFRESH_CURR_REC && (!super.isLineMode() || this._tableRefreshed)) {
+            this.FormRefreshed = true;
+            if (this._task.isFirstRecordCycle() || AccessHelper.eventsManager.getIsInViewRefresh()) {
+                Commands.addNoParameters(CommandType.SET_WC_IDLE, this);
+                AccessHelper.eventsManager.setIsInViewRefresh(false);
+            }
+        }
+        return true;
+    }
+    RefreshUI() {
+        if (!this.getTask().isMainProg()) {
+            Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());
+        }
+    }
+    async refreshTable() {
+        if (this.isFetchingRecordsAhead)
+            return;
+        Logger.Instance.WriteGuiToLog("Start form.refreshTable()");
+        this.updateDisplayLineByDV();
+        let oldCurrRow = this.DisplayLine;
+        let currRecIdx = this.GetDataview().getCurrRecIdx();
+        if (!this._tableRefreshed && currRecIdx >= 0) {
+            oldCurrRow = this.GetDataview().getCurrRecIdx();
+            if (oldCurrRow + 1 > this._rowsInPage)
+                this.GetDataview().setTopRecIdx(oldCurrRow - Math.floor(this._rowsInPage / 2) + 1);
+            else
+                this.GetDataview().setTopRecIdx(0);
+        }
+        else {
+            if (oldCurrRow === Int32.MinValue)
+                oldCurrRow = 0;
+            if (this.GetDataview().getTopRecIdx() === Int32.MinValue)
+                this.GetDataview().setTopRecIdx(currRecIdx);
+        }
+        if (this.GetDataview().getTopRecIdx() < 0)
+            return;
+        oldCurrRow = oldCurrRow - this.GetDataview().getTopRecIdx();
+        let bkpRecord = this.GetDataview().backupCurrent();
+        this._tableRefreshed = true;
+        let oriTransferDataToGui = this._transferringDataToGUI;
+        if (!oriTransferDataToGui)
+            this._transferringDataToGUI = true;
+        this.AllowedSubformRecompute = false;
+        for (let i = 0; i < this._rowsInPage; i++) {
+            let topIndex = this.GetDataview().getTopRecIdx();
+            if (topIndex < 0) {
+                this.GetDataview().setTopRecIdx(0);
+                topIndex = 0;
+            }
+            let idx = topIndex + i;
+            try {
+                super.checkAndCreateRow(idx);
+                if (i !== oldCurrRow) {
+                    await this.setCurrRowByDisplayLine(idx, false, true);
+                    await super.refreshControls(true);
+                }
+            }
+            catch (ex) {
+                if (ex.name == "RecordOutOfDataViewException") {
+                    if (super.isRowCreated(idx))
+                        super.markRowNOTCreated(idx);
+                    break;
+                }
+                else
+                    throw ex;
+            }
+        }
+        this.AllowedSubformRecompute = true;
+        if (!oriTransferDataToGui)
+            this._transferringDataToGUI = false;
+        await this.restoreBackup(oldCurrRow + this.GetDataview().getTopRecIdx(), bkpRecord);
+        await super.refreshControls(true);
+        this.RefreshUI();
+        Logger.Instance.WriteGuiToLog("End form.refreshTable()");
+    }
+    updateDisplayLineByDV() {
+        this.DisplayLine = this.recordIdx2DisplayLine(this.GetDataview().getCurrRecIdx());
+    }
+    async setCurrRowByDisplayLine(displayLine, doSuffix, ignoreCurrRec) {
+        let recIdx = this.displayLine2RecordIdx(displayLine);
+        await this.setCurrRowByRecIdx(recIdx, doSuffix, ignoreCurrRec, displayLine);
+        if (super.HasTable())
+            this.updateDisplayLineByDV();
+        else
+            this.DisplayLine = displayLine;
+    }
+    async setCurrRowByRecIdx(rowNum, doSuffix, ignoreCurrRec, displayLine) {
+        if (this.GetDataview() === null || (!super.hasTable() && rowNum !== 0))
+            throw new ApplicationException("in Form.setCurrRow() no table ");
+        try {
+            this._destTblRow = rowNum;
+            await this.GetDataview().setCurrRecByIdx(rowNum, doSuffix, ignoreCurrRec, true, displayLine);
+        }
+        finally {
+            this._destTblRow = rowNum - this.GetDataview().getTopRecIdx();
+        }
+    }
+    getLastValidRow() {
+        return Math.min(this._rowsInPage - 1, this.GetDataview().getSize() - 1 - this.GetDataview().getTopRecIdx());
+    }
+    recordIdx2DisplayLine(recIdx) {
+        return recIdx;
+    }
+    displayLine2RecordIdx(displayLine) {
+        return displayLine;
+    }
+    async restoreOldDisplayLine(displayLine) {
+        try {
+            this._inRestore = true;
+            await this.setCurrRowByDisplayLine(displayLine, false, true);
+        }
+        catch (ex) {
+            if (ex instanceof RecordOutOfDataViewException) {
+            }
+            else
+                throw ex;
+        }
+        finally {
+            this._inRestore = false;
+        }
+    }
+    getTopIndexFromGUI() {
+        let topDisplayLine = super.getTopIndexFromGUI();
+        if (super.hasTable())
+            this.GetDataview().setTopRecIdx(this.displayLine2RecordIdx(topDisplayLine));
+        return topDisplayLine;
+    }
+    getCurrRecPosInForm() {
+        let topDisplayLine = super.getTopIndexFromGUI();
+        return this.DisplayLine - topDisplayLine + 1;
+    }
+    async restoreBackup(oldDisplayLine, bkpRecord) {
+        if (bkpRecord.getId() >= 0 && this.GetDataview().getRecIdx(bkpRecord.getId()) >= 0 && oldDisplayLine >= 0 && oldDisplayLine < this.GetDataview().getSize() && this.GetDataview().getCurrRecIdx() >= 0 && bkpRecord.getMode() === DataModificationTypes.None) {
+            this.GetDataview().restoreCurrent(bkpRecord);
+            this.updateDisplayLineByDV();
+        }
+        else
+            await this.restoreOldDisplayLine(oldDisplayLine);
+    }
+    ConstructMgControl(type, taskOrParentMgForm, parentControlOrParentControlIdx) {
+        if (arguments.length === 0) {
+            return this.ConstructMgControl_0();
+        }
+        if (arguments.length === 3 && (type === null || type.constructor === Number) && (taskOrParentMgForm === null || taskOrParentMgForm instanceof TaskBase) && (parentControlOrParentControlIdx === null || parentControlOrParentControlIdx.constructor === Number)) {
+            return this.ConstructMgControl_1(type, taskOrParentMgForm, parentControlOrParentControlIdx);
+        }
+        return this.ConstructMgControl_2(type, taskOrParentMgForm, parentControlOrParentControlIdx);
+    }
+    ConstructMgControl_0() {
+        return new MgControl();
+    }
+    ConstructMgControl_1(type, task, parentControl) {
+        return new MgControl(type, task, parentControl);
+    }
+    ConstructMgControl_2(type, parentMgForm, parentControlIdx) {
+        return new MgControl(type, parentMgForm, parentControlIdx);
+    }
+    alreadyMovedToFirstControl() {
+        return this._task.getMGData().AlreadyMovedToFirstControl();
+    }
+    async firstTableRefresh() {
+        if (this._tableMgControl !== null) {
+            super.firstTableRefresh();
+            this.setTableItemsCount(false);
+            await this.refreshTable();
+            super.SelectRow();
+        }
+    }
+    InsertTableItems(idx, count) {
+        if (this._tableMgControl != null) {
+            this.Rows.InsertRange(new Array(count));
+            this.InsertTableChildrenArrays(idx, count);
+            this._lastRowSent = -1;
+        }
+        this.setTableItemsCount(false);
+    }
+    setTableItemsCount(removeAll) {
+        let tableItemsCount;
+        if (this.isTableWithAbsoluteScrollbar()) {
+            if (this._task.getOriginalTaskMode() === Constants.TASK_MODE_CREATE
+                && this._task.getMode() == Constants.TASK_MODE_CREATE) {
+                tableItemsCount = this.GetDataview().getSize();
+                if (this.GetDataview().RecordsBeforeCurrentView > 0) {
+                    this.GetDataview().RecordsBeforeCurrentView = 0;
+                    this.SetRecordsBeforeCurrentView(0);
+                    this.RefreshUI();
+                }
+            }
+            else {
+                tableItemsCount = (this.GetDataview().TotalRecordsCount > 0) ? this.GetDataview().TotalRecordsCount : 1;
+                this.SetRecordsBeforeCurrentView(this.GetDataview().RecordsBeforeCurrentView);
+            }
+        }
+        else {
+            tableItemsCount = this.GetDataview().getSize();
+        }
+        super.SetTableItemsCount(this.GetDataview().getSize(), tableItemsCount, removeAll);
+    }
+    InitTableControl(dvSize, tableItemsCount, removeAll) {
+        if (arguments.length === 0) {
+            this.InitTableControl_00();
+            return;
+        }
+        this.InitTableControl_01(dvSize, tableItemsCount, removeAll);
+    }
+    InitTableControl_00() {
+        let dvSize = 1;
+        let tableItemsCount = 1;
+        if (this.isTableWithAbsoluteScrollbar() && this.GetDataview().TotalRecordsCount > 0) {
+            let recordsBeforeCurrentView = this.GetDataview().RecordsBeforeCurrentView;
+            tableItemsCount = this.GetDataview().TotalRecordsCount;
+            Commands.addWithNumber(CommandType.SET_RECORDS_BEFORE_CURRENT_VIEW, this._tableMgControl, recordsBeforeCurrentView);
+        }
+        this.InitTableControl(dvSize, tableItemsCount, false);
+        this.SetTableTopIndex();
+    }
+    InitTableControl_01(dvSize, tableItemsCount, removeAll) {
+        if (this._tableMgControl !== null) {
+            if (removeAll) {
+                Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_FIRST, this._tableMgControl, 0, true);
+                Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_LAST, this._tableMgControl, 0, true);
+            }
+            else {
+                Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_FIRST, this._tableMgControl, 0, this.GetDataview().IncludesFirst() || this.GetDataview().IsOneWayKey);
+                Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_LAST, this._tableMgControl, 0, this.GetDataview().IncludesLast());
+                Commands.addBoolWithLine(CommandType.SET_EMPTY_DATAVIEW, this._tableMgControl, 0, this.GetDataview().isEmptyDataview());
+            }
+            super.InitTableControl(dvSize, tableItemsCount, removeAll);
+            this.checkAndCreateRowsEvent();
+        }
+    }
+    SetTableTopIndex() {
+        if (this._tableMgControl !== null) {
+            let index = this.GetDataview().getTopRecIdx();
+            if (index === Int32.MinValue)
+                index = 0;
+            if (!this.isTableWithPagination()) {
+                if (this.GetDataview().IncludesLast()) {
+                    if (index + this._rowsInPage > this.GetDataview().getSize()) {
+                        if (this.GetDataview().IncludesFirst() || this.GetDataview().getSize() > this._rowsInPage + 1) {
+                            index = Math.max(this.GetDataview().getSize() - this._rowsInPage, 0);
+                            this.GetDataview().setTopRecIdx(index);
+                            this._topIndexUpdated = true;
+                        }
+                    }
+                }
+            }
+            if (index !== this._prevGuiTopIndex || this.IsMovingInView) {
+                Commands.addWithNumber(CommandType.SET_TABLE_TOP_INDEX, this._tableMgControl, index);
+                this._prevGuiTopIndex = this.getGuiRowidx(index);
+            }
+        }
+    }
+    async createForm() {
+        await super.createForm();
+        MgForm.CreatedForms.add(this);
+    }
+    UpdateStatusBar() {
+    }
+    initInnerObjects(foundTagName) {
+        if (foundTagName === null)
+            return false;
+        let parser = Manager.GetCurrentRuntimeContext().Parser;
+        if (foundTagName === XMLConstants.MG_TAG_RECOMPUTE) {
+            Logger.Instance.WriteDevToLog("goes to recompute form");
+            this._task.RecomputeFillData(parser);
+            return true;
+        }
+        return super.initInnerObjects(foundTagName);
+    }
+    toString() {
+        return "{" + this.constructor.name + ": task=" + this._task + ", Id=" + this._userStateId + "}";
+    }
+    GetHiddenControlListXML() {
+        let xml = new StringBuilder();
+        if (this.hiddenControlsIsnsList !== null && this.hiddenControlsIsnsList.length > 0) {
+            xml.Append("<" + ConstInterface.MG_TAG_HIDDEN_CONTOLS + " " + ConstInterface.MG_ATTR_ISNS + "=\"");
+            this.hiddenControlsIsnsList.forEach((change) => {
+                xml.Append(change + ",");
+            });
+            xml.Remove(xml.Length - 1, 1);
+            xml.Append("\"/>");
+            this.hiddenControlsIsnsList = null;
+        }
+        return xml.ToString();
+    }
+    ShouldBehaveAsModal() {
+        let shouldBeModal = false;
+        if (!this._task.IsInteractive && !this._task.isMainProg())
+            shouldBeModal = TaskBase.ShouldNonInteractiveBeModal();
+        else {
+            let parentTask = this._task.ParentTask;
+            if (parentTask !== null && !parentTask.IsInteractive && !parentTask.isMainProg())
+                shouldBeModal = parentTask.ShouldNonInteractiveChildBeModal();
+        }
+        return shouldBeModal;
+    }
+    isTableWithPagination() {
+        return this.isTableWithAbsoluteScrollbar();
+    }
+    isTableWithAbsoluteScrollbar() {
+        let tableWithAbsoluteScrollbar = false;
+        if (this._tableMgControl !== null)
+            tableWithAbsoluteScrollbar = this._tableMgControl.IsTableWithAbsoluteScrollbar();
+        return tableWithAbsoluteScrollbar;
+    }
+    SetRecordsBeforeCurrentView(value) {
+        if (this._tableMgControl !== null) {
+            Commands.addWithNumber(CommandType.SET_RECORDS_BEFORE_CURRENT_VIEW, this._tableMgControl, value);
+        }
+    }
+    buildFormName() {
+        let name = this.UniqueName;
+        let task = this.getTask();
+        name = (task.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue() + '_' + name;
+        while (task.IsSubtask) {
+            task = task.StudioParentTask;
+            name = (task.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue() + '_' + name;
+        }
+        name = name.replace(/ /g, "_");
+        name = name.replace(/-/g, "_");
+        return name;
+    }
+    async fetchPrevChunkForCurrentPage() {
+        if (this.isTableWithAbsoluteScrollbar() && this.GetDataview().TotalRecordsCount > 0) {
+            let recPosOnPage = this.GetDataview().RecordsBeforeCurrentView % this._rowsInPage;
+            if (recPosOnPage > 0 && this.DisplayLine === 0) {
+                await this.setRowData(-recPosOnPage, false);
+            }
+        }
+    }
+    getGuiRowidx(dvRowIdx) {
+        return dvRowIdx + this.GetDataview().RecordsBeforeCurrentView;
+    }
+    getDvRowIdx(guiRowIdx) {
+        return guiRowIdx - this.GetDataview().RecordsBeforeCurrentView;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MgForm.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/gui/MgForm.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Commands,\r\n  CommandType,\r\n  ControlTable,\r\n  DataModificationTypes,\r\n  GuiEnvironment,\r\n  Manager,\r\n  MgControlBase,\r\n  MgFormBase,\r\n  PropInterface,\r\n  Row\r\n} from '@magic-xpa/gui';\r\nimport {\r\n  Constants,\r\n  InternalInterface,\r\n  Logger,\r\n  MgControlType,\r\n  Misc,\r\n  Priority,\r\n  XMLConstants,\r\n  XmlParser\r\n} from '@magic-xpa/utils';\r\nimport {\r\n  ApplicationException,\r\n  Debug,\r\n  Exception,\r\n  Int32,\r\n  List,\r\n  NString,\r\n  RefParam,\r\n  StringBuilder\r\n} from '@magic-xpa/mscorelib';\r\nimport {MgControl} from './MgControl';\r\nimport {RecordOutOfDataViewException} from '../data/RecordOutOfDataViewException';\r\nimport {DataView, SET_DISPLAYLINE_BY_DV} from '../data/DataView';\r\nimport {Record} from '../data/Record';\r\nimport {TaskBase} from '../tasks/TaskBase';\r\nimport {ServerError} from '../remote/ServerError';\r\nimport {ConstInterface} from '../ConstInterface';\r\nimport {LastFocusedManager} from '../rt/LastFocusedManager';\r\nimport {CreatedFormVector} from './CreatedFormVector';\r\nimport {AccessHelper} from '../AccessHelper';\r\n\r\n/// <summary>\r\n///   data for <form>...</form>\r\n/// </summary>\r\n// @dynamic\r\nexport class MgForm extends MgFormBase {\r\n  private static TIME_LIMIT: number = 50; // time limit for one transfer operation (in milli seconds)\r\n  IsMovingInView: boolean = false;\r\n  PrevDisplayLine: number = 0; // display identifier of prev line\r\n  RefreshAllRows: boolean = false;\r\n\r\n  IgnoreFirstRecordCycle: boolean = false;\r\n  MovedToFirstControl: boolean = false; // true when move to first control should be executed on the form\r\n\r\n  private _suffixDone: boolean = false;\r\n\r\n  private hiddenControlsIsnsList: List<number> = null;\r\n\r\n  static _createdForms: CreatedFormVector = new CreatedFormVector();\r\n\r\n  //TODO: Maybe the name should be changed to something like allowFieldCompute\r\n  private _transferringDataToGUI: boolean = false;\r\n\r\n  private isFetchingRecordsAhead: boolean = false;\r\n\r\n  constructor() {\r\n    super();\r\n  }\r\n\r\n  static get CreatedForms(): CreatedFormVector {\r\n    return MgForm._createdForms;\r\n  }\r\n\r\n  get InRestore(): boolean {\r\n    return this._inRestore;\r\n  }\r\n\r\n  get TransferringDataToGUI(): boolean {\r\n    return this._transferringDataToGUI;\r\n  }\r\n\r\n  get shouldFetchRecordsAheadFromServer(): boolean {\r\n    if (this.isTableWithPagination()) {\r\n      let prop = this._tableMgControl.GetComputedProperty(PropInterface.PROP_TYPE_SERVER_READ_AHEAD);\r\n\r\n      return (prop != null ? prop.GetComputedValueBoolean() : false);\r\n    }\r\n    else\r\n      return false;\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  async FetchRecordsAheadFromServer(): Promise<void> {\r\n    this.isFetchingRecordsAhead = true;\r\n    await this.GetDataview().FetchRecordsAheadFromServer();\r\n    this.isFetchingRecordsAhead = false;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the task dataview, if the task exist\r\n  /// </summary>\r\n  /// <returns>the task dataview</returns>\r\n  private GetDataview(): DataView {\r\n    let dv: DataView = null;\r\n\r\n    if (this._task != null)\r\n      dv = <DataView>this._task.DataView;\r\n\r\n    return (dv);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   move one page/row up/down or to the beginning/end of table\r\n  /// </summary>\r\n  /// <param name = \"unit\">to move into</param>\r\n  /// <param name = \"Direction\">of moving</param>\r\n  async moveInView(unit: string, direction: string): Promise<void> {\r\n    let oldRecId: number = Int32.MinValue;\r\n    let currRec: Record = this.GetDataview().getCurrRec();\r\n    let oldTaskMode: string = ' ';\r\n    let returnToVisibleLine: boolean = false;\r\n    let recordOutOfView: boolean = false;\r\n    let visibleLine: number = 0;\r\n\r\n    try {\r\n      this.IsMovingInView = true;\r\n      let oldDisplayLine: number = this.DisplayLine;\r\n\r\n      // table movements (first / last record)\r\n      if (unit === Constants.MOVE_UNIT_TABLE) {\r\n        try {\r\n          // BEGINING OF TABLE\r\n          if (direction === Constants.MOVE_DIRECTION_BEGIN) {\r\n            await this.GetDataview().setCurrRecByIdx(Constants.MG_DATAVIEW_FIRST_RECORD, true, false, true,\r\n              SET_DISPLAYLINE_BY_DV);\r\n            // check if there is a table in the form\r\n            if (this.isLineMode()) {\r\n              this.GetDataview().setTopRecIdx(0);\r\n              await this.setCurrRowByDisplayLine(0, false, false);\r\n            }\r\n          }\r\n          // END OF TABLE\r\n          else {\r\n            await this.GetDataview().setCurrRecByIdx(Constants.MG_DATAVIEW_LAST_RECORD, true, false, true,\r\n              SET_DISPLAYLINE_BY_DV);\r\n            // check if there is a table in the form\r\n            if (this.isLineMode()) {\r\n              this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx() - this._rowsInPage + 1);\r\n              if (this.GetDataview().getTopRecIdx() >= 0)\r\n                await this.setCurrRowByDisplayLine(this.GetDataview().getCurrRecIdx(), false, false);\r\n              else {\r\n                this.GetDataview().setTopRecIdx(0);\r\n                await this.setCurrRowByDisplayLine(this.GetDataview().getCurrRecIdx(), false, false);\r\n              }\r\n            }\r\n          }\r\n          this.updateDisplayLineByDV();\r\n\r\n          await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n        }\r\n        catch (ex) {\r\n          if (ex instanceof RecordOutOfDataViewException)\r\n            Logger.Instance.WriteDevToLog(ex.Message);\r\n        }\r\n      }\r\n      // page and row movements\r\n      else {\r\n        this.getTopIndexFromGUI();\r\n        // calculate the amount of records to skip\r\n        let size: number;\r\n        if (unit === Constants.MOVE_UNIT_PAGE && this.isLineMode()) {\r\n          switch (direction) {\r\n            case Constants.MOVE_DIRECTION_BEGIN:\r\n              size = this.GetDataview().getCurrRecIdx() - this.GetDataview().getTopRecIdx();\r\n              break;\r\n            case Constants.MOVE_DIRECTION_END:\r\n\r\n              let last: number = this.GetDataview().getTopRecIdx() + this._rowsInPage - 1;\r\n              last = Math.min(last, this.GetDataview().getSize() - 1);\r\n              size = last - this.GetDataview().getCurrRecIdx();\r\n              break;\r\n            default:\r\n              returnToVisibleLine = true;\r\n              size = this._rowsInPage;\r\n              break;\r\n          }\r\n        }\r\n        else\r\n          size = 1;\r\n\r\n        size = (direction === Constants.MOVE_DIRECTION_PREV ||\r\n        direction === Constants.MOVE_DIRECTION_BEGIN\r\n          ? -size\r\n          : size);\r\n\r\n        if (this.isLineMode()) {\r\n          visibleLine = this.getVisibleLine();\r\n          if (visibleLine < 0) {\r\n            visibleLine = 0;\r\n            recordOutOfView = true;\r\n          }\r\n          if (visibleLine > this._rowsInPage + 1) {\r\n            visibleLine = this._rowsInPage;\r\n            recordOutOfView = true;\r\n          }\r\n          // scrolling the table one page or one row up or down\r\n          if (unit === Constants.MOVE_UNIT_PAGE &&\r\n            (direction === Constants.MOVE_DIRECTION_NEXT ||\r\n              direction === Constants.MOVE_DIRECTION_PREV) ||\r\n            unit === Constants.MOVE_UNIT_ROW &&\r\n            (direction === Constants.MOVE_DIRECTION_NEXT && visibleLine === this._rowsInPage - 1 ||\r\n              direction === Constants.MOVE_DIRECTION_PREV && visibleLine === 0)) {\r\n            // if we move to the previous row but we are at the first row of the table and data view\r\n            // then do nothing\r\n            if (direction === Constants.MOVE_DIRECTION_PREV &&\r\n              (unit === Constants.MOVE_UNIT_ROW || unit === Constants.MOVE_UNIT_PAGE) &&\r\n              visibleLine === 0 && this.GetDataview().getCurrRecIdx() === 0 && this.GetDataview().IncludesFirst())\r\n              return;\r\n\r\n            // if we move to the next row but we are at the last row of the table and the data view\r\n            // then do nothing\r\n            if (direction === Constants.MOVE_DIRECTION_NEXT && unit === Constants.MOVE_UNIT_PAGE &&\r\n              visibleLine === this.getLastValidRow() && this.GetDataview().getCurrRecIdx() === this.GetDataview().getSize() - 1 && this.GetDataview().IncludesLast())\r\n              return;\r\n\r\n            oldRecId = (this.GetDataview().getCurrRec()).getId();\r\n            this.GetDataview().setTopRecIdx(this.GetDataview().getTopRecIdx() + size);\r\n            (<DataView>this.GetDataview()).setTopRecIdxModified(true);\r\n            try {\r\n              this._suffixDone = false;\r\n\r\n              await this.setCurrRowByDisplayLine(this.GetDataview().getCurrRecIdx() + size, true, false);\r\n              (<DataView>this.GetDataview()).setTopRecIdxModified(false);\r\n              await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n            }\r\n            catch (ex) {\r\n              if (ex instanceof RecordOutOfDataViewException) {\r\n                (<DataView>this.GetDataview()).setTopRecIdxModified(false);\r\n                if (AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n                  (<DataView>this.GetDataview()).restoreTopRecIdx();\r\n                  await this.restoreOldDisplayLine(oldDisplayLine);\r\n                  return;\r\n                }\r\n                if (this.GetDataview().getTopRecIdx() < 0) {\r\n                  this.GetDataview().setTopRecIdx(0);\r\n                  try {\r\n                    await this.setCurrRowByDisplayLine(0, true, false);\r\n                  }\r\n                  catch (exception) {\r\n                    if (exception instanceof Exception) {\r\n                      // QCR #995496: when the record suffix failed go back to the\r\n                      // original row\r\n                      if (AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n                        (<DataView>this.GetDataview()).restoreTopRecIdx();\r\n                        await this.restoreOldDisplayLine(oldDisplayLine);\r\n                        return;\r\n                      }\r\n                    }\r\n                  }\r\n                  await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n                }\r\n                else if (unit !== Constants.MOVE_UNIT_ROW && (<DataView>this.GetDataview()).recExists(this.GetDataview().getTopRecIdx())) {\r\n                  // QCR #992101: if we reached this point it means that the rec suffix\r\n                  // wasn't executed so we must handle it before we go to a new row\r\n                  let newRecId: number = (this.GetDataview().getCurrRec()).getId();\r\n                  if (newRecId === oldRecId && !this._suffixDone)\r\n                    // QCR 758639\r\n                  {\r\n                    await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n                    if (AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n                      (<DataView>this.GetDataview()).restoreTopRecIdx();\r\n                      await this.restoreOldDisplayLine(oldDisplayLine);\r\n                      return;\r\n                    }\r\n                    try {\r\n                      await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n                      await this.setCurrRowByDisplayLine(this.GetDataview().getTopRecIdx() + this.getLastValidRow(), false, true);\r\n                      visibleLine = this.getLastValidRow();\r\n                    }\r\n                    catch (Exception) {\r\n                    }\r\n                  }\r\n                }\r\n                else {\r\n                  (<DataView>this.GetDataview()).restoreTopRecIdx();\r\n                  await this.restoreOldDisplayLine(oldDisplayLine);\r\n                  if (unit === Constants.MOVE_UNIT_ROW && direction === Constants.MOVE_DIRECTION_NEXT) {\r\n                    // non interactive, end of data means end of ownerTask, unless we are in create mode.\r\n                    if (!this._task.IsInteractive && this._task.getMode() !== Constants.TASK_MODE_CREATE)\r\n                      (<TaskBase>this._task).setExecEndTask();\r\n                    else\r\n                      await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);\r\n                  }\r\n                  return;\r\n                }\r\n                Logger.Instance.WriteDevToLog(ex.Message);\r\n              }\r\n            }\r\n          }\r\n          // moving the marking one row up or down\r\n          else {\r\n            try {\r\n              oldTaskMode = this._task.getMode();\r\n\r\n              oldRecId = (this.GetDataview().getCurrRec()).getId();\r\n              await this.setCurrRowByDisplayLine(oldDisplayLine + size, true, false);\r\n\r\n              // if the record was deleted in Run Time by Force Delete for example\r\n              if (!(<DataView>this.GetDataview()).recExistsById(oldRecId)) {\r\n                if (size > 0 || oldTaskMode !== Constants.TASK_MODE_CREATE)\r\n                  if (size !== -1 || (<DataView>this.GetDataview()).recExists(oldDisplayLine))\r\n                    // QCR #293668\r\n                    await this.setCurrRowByDisplayLine(oldDisplayLine, false, false);\r\n                  else\r\n                    Logger.Instance.WriteDevToLog(NString.Format(\"skipped setcurrRow for row {0}\", oldDisplayLine));\r\n                await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n              }\r\n              else if (AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n                // performance improvement: if everything is OK, curr rec will later be refreshed in\r\n                // REC_PREFIX\r\n                // thus, refresh only in case of error.\r\n                await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n              }\r\n            }\r\n            catch (ex) {\r\n              if (ex instanceof RecordOutOfDataViewException) {\r\n                // Sometimes the error is because the old-rec was removed (cancelEdit'ed), so refresh form.\r\n                if ((<DataView>this.GetDataview()).recExistsById(oldRecId)) {\r\n                  await this.restoreOldDisplayLine(oldDisplayLine);\r\n\r\n                  // QCR #775309: if leaving the new created record failed then restore\r\n                  // all the attributes of the a new record so the next action would\r\n                  // \"know\" that it is still a new record.\r\n                  // Defect # 81627 : If task is having a subform, then while moving to subform, newly created record\r\n                  // is synced and it is inserted in _modifiedTab as 'insert' record. So, any request to server inserts\r\n                  // record to server. Even if we dont go to server, it is there in _modifiedTab as new record. Inserting\r\n                  // here already synced record causes insertion of record twice. So, If current record is not synced then only insert.\r\n\r\n                  if (!currRec.Synced && oldTaskMode === Constants.TASK_MODE_CREATE) {\r\n                    this._task.setMode(Constants.TASK_MODE_CREATE);\r\n                    currRec.clearMode();\r\n                    currRec.setMode(DataModificationTypes.Insert);\r\n                    currRec.setNewRec();\r\n                  }\r\n                  // QCR #980528: Refresh the current row after cancel edit to reflect\r\n                  // the restored values\r\n                  await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n                }\r\n                else {\r\n                  if (oldTaskMode === Constants.TASK_MODE_CREATE && oldDisplayLine > 0)\r\n                    await this.restoreOldDisplayLine(oldDisplayLine - 1);\r\n                  await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n                }\r\n                if (size <= 0 || AccessHelper.eventsManager.GetStopExecutionFlag())\r\n                  Logger.Instance.WriteDevToLog(ex.Message);\r\n                else {\r\n                  // non interactive, end of data means end of ownerTask, unless we are in create mode.\r\n                  if (!this._task.IsInteractive && this._task.getMode() !== Constants.TASK_MODE_CREATE) {\r\n                    (<TaskBase>this._task).setExecEndTask();\r\n                    return;\r\n                  }\r\n                  else {\r\n                    if (this._task.ActionManager.isEnabled(InternalInterface.MG_ACT_CRELINE))\r\n                      await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);\r\n                    else {\r\n                      // fixed bug #:941763, while create isn't allowed need to do suffix and prefix of the current record\r\n                      let doRecordSuffix: boolean = true;\r\n                      let refdoRecordSuffix: RefParam<boolean> = new RefParam(doRecordSuffix);\r\n                      if (! await AccessHelper.eventsManager.DoTaskLevelRecordSuffix(<TaskBase>this._task, refdoRecordSuffix))\r\n                        await AccessHelper.eventsManager.DoTaskLevelRecordPrefix(this._task);\r\n                      doRecordSuffix = refdoRecordSuffix.value;\r\n                    }\r\n                  }\r\n                }\r\n                return;\r\n              }\r\n            }\r\n          }\r\n        }\r\n        // if the form does not have a table, move to one row in the chosen Direction\r\n        else {\r\n          try {\r\n            await this.GetDataview().setCurrRecByIdx(this.GetDataview().getCurrRecIdx() + size, true, false, true, SET_DISPLAYLINE_BY_DV);\r\n            await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n          }\r\n          catch (ex) {\r\n            if (ex instanceof RecordOutOfDataViewException) {\r\n              if (size > 0) {\r\n                // non interactive, end of data means end of ownerTask, unless we are in create mode.\r\n                if (!this._task.IsInteractive && this._task.getMode() !== Constants.TASK_MODE_CREATE)\r\n                  (<TaskBase>this._task).setExecEndTask();\r\n                else\r\n                  await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);\r\n              }\r\n              else\r\n                Logger.Instance.WriteDevToLog(ex.Message);\r\n              return;\r\n            }\r\n            else if (ex instanceof ServerError) {\r\n              await (<TaskBase>this._task).stop();\r\n              (<TaskBase>this._task).abort();\r\n              await AccessHelper.eventsManager.ProcessAbortingError(ex);\r\n            }\r\n            else if (ex instanceof Exception) {\r\n              Logger.Instance.WriteDevToLog(ex.Message);\r\n              return;\r\n            }\r\n          }\r\n        }\r\n      }\r\n      if (returnToVisibleLine) {\r\n        if (recordOutOfView) {\r\n          if (visibleLine === 0)\r\n            this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx());\r\n          else\r\n            this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx() - this._rowsInPage);\r\n          this.SetTableTopIndex();\r\n        }\r\n        else {\r\n          this.SetTableTopIndex();\r\n          await this.setCurrRowByDisplayLine(this.GetDataview().getTopRecIdx() + visibleLine, false, true);\r\n        }\r\n      }\r\n      else\r\n        this.SetTableTopIndex();\r\n\r\n      await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_PREFIX);\r\n    }\r\n    catch (e) {\r\n      if (e instanceof RecordOutOfDataViewException) {\r\n        Logger.Instance.WriteDevToLog(e.Message);\r\n      }\r\n    }\r\n    finally {\r\n\r\n      this.SelectRow();\r\n      this.IsMovingInView = false;\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   add a record to the form and make it the current record\r\n  /// </summary>\r\n  async addRec(doSuffix: boolean,isCrelineAbove: boolean): Promise<void> {\r\n    let newLine: number = 1;\r\n    let currLine: number = -1;\r\n\r\n    if (!this._task.DataView.isEmptyDataview())\r\n      currLine = this.getVisibleLine();\r\n\r\n    // Increment the TotalRecordsCount as record being added into the view.\r\n    if (this.isTableWithAbsoluteScrollbar())\r\n    {\r\n      this.GetDataview().TotalRecordsCount += 1;\r\n      this.RefreshAllRows = true;\r\n    }\r\n\r\n    let newRecIdx: number = await (<DataView>this.GetDataview()).addRecord(doSuffix, false, isCrelineAbove);\r\n\r\n    if (newRecIdx > -1) {\r\n      // forms with a table\r\n      if (this.isLineMode()) {\r\n        // there are no records in the table so the new row is created after\r\n        // setting the top record to 0 and the current row to 0\r\n        let newCurrRow: number;\r\n        if (this.GetDataview().getSize() === 0 || this.GetDataview().getTopRecIdx() === Int32.MinValue) {\r\n          this.GetDataview().setTopRecIdx(0);\r\n          newCurrRow = 0;\r\n        }\r\n        // the cursor is parking on the last row of the displayed table so the\r\n        // new row is created after incrementing the top record index\r\n        else if (currLine === this._rowsInPage - 1) {\r\n          this.GetDataview().setTopRecIdx(this.GetDataview().getTopRecIdx() + 1);\r\n          newCurrRow = this.getVisibleLine();\r\n        }\r\n        // the new row is created without changing the top record\r\n        else\r\n        {\r\n          if (isCrelineAbove)\r\n            newCurrRow = currLine > 0 ? currLine : 0;\r\n          else\r\n            newCurrRow = currLine + 1;\r\n        }\r\n\r\n\r\n        newLine = this.GetDataview().getTopRecIdx() + newCurrRow;\r\n\r\n        // invalidates all records after newCurrRow\r\n        this.removeRecordsAfterIdx(this.GetDataview().getTopRecIdx() + newCurrRow);\r\n\r\n        try {\r\n          // invalidates all records after newCurrRow\r\n          if (!this._task.DataView.isEmptyDataview())\r\n            this._task.setMode(Constants.TASK_MODE_CREATE);\r\n          await this.setCurrRowByDisplayLine(newLine, false, false);\r\n        } catch (ex) {\r\n          if (ex instanceof RecordOutOfDataViewException) {\r\n            // no exception should really be caught here\r\n            Logger.Instance.WriteDevToLog(NString.Format(\"in Form.addRec() {0}\", ex.Message));\r\n          }\r\n        }\r\n        await this.RefreshDisplay(Constants.TASK_REFRESH_TABLE);\r\n      }\r\n    }\r\n    else if (this.isTableWithAbsoluteScrollbar())\r\n    {\r\n      this.GetDataview().TotalRecordsCount -= 1;\r\n      this.RefreshAllRows = false;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   delete the current record\r\n  /// </summary>\r\n  async delCurrRec(): Promise<void> {\r\n    let topTableRow: boolean = super.isLineMode() && this.GetDataview().getTopRecIdx() === this.GetDataview().getCurrRecIdx();\r\n\r\n    await this.GetDataview().removeCurrRec();\r\n\r\n    if (this.GetDataview().isEmpty() && !(<TaskBase>this._task).IsTryingToStop) {\r\n      if (this._task.DataView.isEmptyDataview()) {\r\n        await this.addRec(false, false);\r\n      }\r\n      else {\r\n        if (await this._task.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true)) {\r\n          // change to create mode\r\n          if (this._task.getMode() !== Constants.TASK_MODE_CREATE)\r\n            this._task.setMode(Constants.TASK_MODE_CREATE);\r\n\r\n          // MG_ACT_CRELINE may be disabled .i.e. PROP_TYPE_ALLOW_CREATE expression can be changed\r\n          (<TaskBase>this._task).enableCreateActs(true);\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);\r\n        }\r\n        // exit from the ownerTask\r\n        else\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_EXIT);\r\n      }\r\n    }\r\n\r\n    // the emptiness of the DV must be checked again because the \"create line\" may fail\r\n    if (!this.GetDataview().isEmpty()) {\r\n      if (topTableRow)\r\n        this.GetDataview().setTopRecIdx(this.GetDataview().getCurrRecIdx());\r\n\r\n      if (super.isLineMode()) {\r\n        if (super.HasTable()) {\r\n          // Decrement the TotalRecordsCount as record being deleted.\r\n          if (this.isTableWithAbsoluteScrollbar())\r\n          {\r\n            this.GetDataview().TotalRecordsCount--;\r\n            this.RefreshAllRows = true;\r\n          }\r\n\r\n          this.removeRecordsAfterIdx(this.GetDataview().getCurrRecIdx());\r\n          await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n        }\r\n        else\r\n          await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n      }\r\n      // screen mode\r\n      else {\r\n        try {\r\n          await this.GetDataview().setCurrRecByIdx(this.GetDataview().getCurrRecIdx(), true, true, true, SET_DISPLAYLINE_BY_DV);\r\n        }\r\n        catch (ex) {\r\n          if (ex instanceof RecordOutOfDataViewException) {\r\n          }\r\n          else\r\n            throw ex;\r\n        }\r\n        await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   cancel the editing of the current record and restore the old values of the fields\r\n  /// </summary>\r\n  /// <param name = \"isActCancel\">true if called for ACT_CANCEL, false otherwise</param>\r\n  /// <param name = \"isQuitEvent\"></param>\r\n  async cancelEdit(isActCancel: boolean, isQuitEvent: boolean): Promise<void> {\r\n    let mode: string = this._task.getMode();\r\n    let newMode: string;\r\n    let row: number = 0;\r\n    let execRecPrefix: boolean = false;\r\n\r\n    // We return to create mode only if there is no record to go to after the cancel action\r\n    if (this.GetDataview().getSize() === 1 && mode === Constants.TASK_MODE_CREATE)\r\n      newMode = Constants.TASK_MODE_CREATE;\r\n    else\r\n      newMode = Constants.TASK_MODE_MODIFY;\r\n\r\n    /**********************************************************************/\r\n    // 997073 & 931021.\r\n    // Expected behavior during cancel event, for a new record:\r\n    // If the original ownerTask mode is not create, delete the new record and go back to the previous record.\r\n    // If the original ownerTask mode is create, stay on the new record.\r\n\r\n    // dv.cancelEdit() removes the new record under some condition.\r\n    // So, in case of orgTaskMode=C, since we want to stay on the new record, we need to re-create a record.\r\n\r\n    // But as said, dv.cancelEdit() removes the new record ONLY under some condition.\r\n    // The condition is as follows:\r\n    // The record is removed only if the dv size is greater than 1. So, if the dv size is 1, dv.cancelEdit()\r\n    // does not remove the record and hence in this case, form.cancelEdit() should not create a new record.\r\n    // For this reason, the signature of dv.cancelEdit() is changed to indicate whether the record was removed or not.\r\n\r\n    // This is one part.\r\n\r\n    // Now, after cancelEdit, RP has to be executed. This was done in EventsManager.commonHandler()->case MG_ACT_CANCEL.\r\n    // But what happens is, if form.cancelEdit() created a new line, RP was already executed from there. And from\r\n    // EventsManager.commonHandler(), RP is executed for the second time.\r\n    // So, moved the code of executing RP from EventsManager.commonHandler()->case MG_ACT_CANCEL to form.cancelEdit()\r\n    // and that will be done only if the create line was not executed.\r\n\r\n    // Now, we have one more issue.\r\n\r\n    // Until now, the RP was executed after form.cancelEdit().\r\n    // So, when the code is moved to form.cancelEdit(), it should be the last thing to be executed.\r\n    /**********************************************************************/\r\n\r\n    let recRemoved: boolean = await this.GetDataview().cancelEdit(false, false);\r\n    this.GetDataview().setPrevCurrRec(null);\r\n    if ((this.GetDataview().isEmpty() || ((isActCancel && recRemoved) && (!GuiEnvironment.Environment.GetSpecialCancelOnCreate())&&(<TaskBase>this._task).getOriginalTaskMode() === Constants.TASK_MODE_CREATE)) && !(<TaskBase>this._task).IsTryingToStop) {\r\n      // Set Cancel indication on the task for to not perform control value validation in the Create line action.\r\n      let orgCancelWasRaised: boolean = (<TaskBase>this._task).cancelWasRaised();\r\n      (<TaskBase>this._task).setCancelWasRaised(isActCancel);\r\n      await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_CRELINE);\r\n      (<TaskBase>this._task).setCancelWasRaised(orgCancelWasRaised);\r\n    }\r\n    else if (isActCancel)\r\n      execRecPrefix = true;\r\n\r\n    // the emptiness of the DV must be checked again because the \"create line\" may fail\r\n    if (!this.GetDataview().isEmpty()) {\r\n      if (super.isLineMode()) {\r\n        try {\r\n          if (super.HasTable()) {\r\n            row = this.getVisibleLine();\r\n            if (row < 0 || row >= this._rowsInPage) {\r\n              let topRecIdx: number = this.GetDataview().getTopRecIdx();\r\n              let currRecIdx: number = this.GetDataview().getCurrRecIdx();\r\n              if (topRecIdx > currRecIdx)\r\n                this.GetDataview().setTopRecIdx(currRecIdx);\r\n              row = 0;\r\n            }\r\n            await this.setCurrRowByDisplayLine(this.GetDataview().getTopRecIdx() + row, false, true);\r\n          }\r\n        }\r\n        catch (ex) {\r\n          if (ex instanceof RecordOutOfDataViewException) {\r\n            // no exception should really be caught here.\r\n            if (row !== 0)\r\n              Logger.Instance.WriteDevToLog(NString.Format(\"in Form.cancelEdit() {0}\", ex.Message));\r\n          }\r\n          else\r\n            throw ex;\r\n        }\r\n        if (super.HasTable()) {\r\n          // Decrement the TotalRecordsCount as record being deleted.\r\n          if (this.isTableWithAbsoluteScrollbar() && recRemoved)\r\n          {\r\n            this.GetDataview().TotalRecordsCount--;\r\n            this.RefreshAllRows = true;\r\n          }\r\n\r\n          this.removeRecordsAfterIdx(this.GetDataview().getCurrRecIdx());\r\n        }\r\n      }\r\n      // screen mode\r\n      else {\r\n        try {\r\n          await this.GetDataview().setCurrRecByIdx(this.GetDataview().getCurrRecIdx(), false, true, true, SET_DISPLAYLINE_BY_DV);\r\n        }\r\n        catch (ex) {\r\n          if (ex instanceof RecordOutOfDataViewException) {\r\n            Logger.Instance.WriteDevToLog(\"in Form.cancelEdit() error in Screen mode for Current Record\");\r\n          }\r\n          else\r\n            throw ex;\r\n        }\r\n      }\r\n      this._task.setMode(newMode);\r\n      if (!(<TaskBase>this._task).InEndTask)\r\n        await this.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n\r\n      if (!(<TaskBase>this._task).InEndTask)\r\n        await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n    }\r\n\r\n    if (execRecPrefix) {\r\n      // QCR #925646, #454167: exit to the ownerTask level in order to skip control suffix\r\n      // and record suffix of the canceled new record and make sure that the\r\n      // next record perfix would be executed\r\n      this._task.setLevel(Constants.TASK_LEVEL_TASK);\r\n      // we rollback a parent ownerTask while focused on subform/ownerTask. We do not want the ctrl on the subform to do ctrl suffix.\r\n      let lastParkedCtrl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n      if (lastParkedCtrl !== null) {\r\n        if ((<TaskBase>lastParkedCtrl.getForm().getTask()).pathContains(<TaskBase>this._task))\r\n          for (let parent = <TaskBase>lastParkedCtrl.getForm().getTask();\r\n               parent !== null && parent !== this._task;\r\n               parent = <TaskBase>parent.getParent()) {\r\n            parent.setLevel(Constants.TASK_LEVEL_TASK);\r\n            ((<DataView>parent.DataView).getCurrRec()).resetModified();\r\n          }\r\n        else\r\n          lastParkedCtrl.getForm().getTask().setLevel(Constants.TASK_LEVEL_TASK);\r\n      }\r\n      if (!isQuitEvent) {\r\n        // TODO: Check if following 2 lines can be merged in one method\r\n        await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_PREFIX);\r\n        await AccessHelper.eventsManager.HandleParkabilityOnRowChange(this._task);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   scan all controls in the form. Every control which has a property that is an expression will be\r\n  ///   refreshed. This is done to ensure the control's display is synched with the expressin's value\r\n  /// </summary>\r\n  async refreshOnExpressions(): Promise<void> {\r\n    for (let i: number = 0; i < this.CtrlTab.getSize(); i = i + 1) {\r\n      let mgControl: MgControl = ((this.CtrlTab.getCtrl(i) instanceof MgControl) ? <MgControl>this.CtrlTab.getCtrl(i) : null);\r\n\r\n      if (mgControl != null)\r\n        await mgControl.refreshOnExpression();\r\n      else\r\n        Debug.Assert(false);\r\n    }\r\n    // refresh the form properties\r\n    await super.refreshPropsOnExpression();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   remove references to the controls of this form\r\n  /// </summary>\r\n  removeRefsToCtrls(): void {\r\n    // if last focused control was from this task - zero it.\r\n    let lastFocusedControl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n    if (lastFocusedControl !== null && lastFocusedControl.getForm() === this)\r\n      LastFocusedManager.setLastFocusedControl(<TaskBase>this._task, null);\r\n\r\n    super.removeRefsToCtrls();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Return the control with a given name\r\n  /// </summary>\r\n  /// <param name = \"ctrlName\">the of the requested control</param>\r\n  /// <returns> a reference to the control with the given name or null if does not exist</returns>\r\n  getCtrlByCtrlName(ctrlName: string): MgControl {\r\n    return <MgControl>this.CtrlTab.getCtrl(ctrlName);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Return the subform control with the typed name from all parents\r\n  /// </summary>\r\n  /// <param name = \"ctrlName\"> the requested subform control</param>\r\n  /// <returns>a reference to the control with the given name or null if does not exist</returns>\r\n  getSubFormCtrlByName(ctrlName: string): MgControl {\r\n    let guiParentTask: TaskBase;\r\n    let destSubForm: MgControl = null;\r\n\r\n    for (guiParentTask = <TaskBase>this._task;\r\n         destSubForm === null && guiParentTask !== null && guiParentTask.getForm() !== null;\r\n         guiParentTask = guiParentTask.getParent()) {\r\n      destSubForm = <MgControl>guiParentTask.getForm().getCtrlByName(ctrlName, MgControlType.CTRL_TYPE_SUBFORM);\r\n      if (destSubForm == null) {\r\n        if (!guiParentTask.IsSubForm || NString.Equals(guiParentTask.getForm().getSubFormCtrl().Name, ctrlName, true))\r\n          break;\r\n      }\r\n    }\r\n\r\n    return destSubForm;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets suffixDone parameter to true\r\n  /// </summary>\r\n  setSuffixDone(): void {\r\n    this._suffixDone = true;\r\n  }\r\n\r\n  getDestinationRow(): number {\r\n    return this._destTblRow;\r\n  }\r\n\r\n  setSubFormCtrl(subFormCtrl: MgControl): void {\r\n    Debug.Assert(this._subFormCtrl === null && subFormCtrl !== null);\r\n    this._subFormCtrl = subFormCtrl;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns a subform control that points to a task whose id is given in taskId\r\n  /// </summary>\r\n  /// <param name = \"taskId\">the id of requested subform ownerTask</param>\r\n  getSubFormCtrlForTask(taskId: string): MgControl {\r\n    let curr: MgControl = null;\r\n    let parentCtrlTab: ControlTable;\r\n    let guiParentForm: MgFormBase = null;\r\n    let destSubForm: MgControl = null;\r\n\r\n    for (guiParentForm = this; guiParentForm != null; guiParentForm = guiParentForm.ParentForm) {\r\n      parentCtrlTab = guiParentForm.CtrlTab;\r\n      for (let i: number = 0; i < parentCtrlTab.getSize(); i++) {\r\n        curr = ((parentCtrlTab.getCtrl(i) instanceof MgControl) ? <MgControl>parentCtrlTab.getCtrl(i) : null);\r\n        if (curr != null && curr.isSubform() && (curr.getSubformTaskId() != null))\r\n          if (curr.getSubformTaskId() === taskId) {\r\n            destSubForm = curr;\r\n            break;\r\n          }\r\n      }\r\n\r\n      if (destSubForm != null)\r\n        break;\r\n    }\r\n    return destSubForm;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   recreate records between idx and end of dataview\r\n  /// </summary>\r\n  /// <param name = \"idx\"></param>\r\n  removeRecordsAfterIdx(idx: number): void {\r\n    let removeAll: boolean = false;\r\n\r\n    // in some cases invisible -1 row (that exist only for scrollbar effects) becomes visible.\r\n    // To prevent this we'll remove all records. This will not cause perfromance problems since\r\n    // we will add maximum rowInPage records more then we intended in the begining\r\n\r\n    if (this.isTableWithPagination())\r\n      this.setTableItemsCount(false);\r\n    else {\r\n      if (idx <= this._rowsInPage + 1 && this.GetDataview().getSize() > this._rowsInPage)\r\n        idx = 0;\r\n      if (idx === 0)\r\n        removeAll = true;\r\n\r\n      // invalidates all records after newCurrRow\r\n      super.SetTableItemsCount(idx, removeAll);\r\n      // updates table item's count\r\n\r\n      this.setTableItemsCount(false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if row is valid\r\n  /// </summary>\r\n  /// <param name = \"idx\"></param>\r\n  /// <returns></returns>\r\n  isRowValidated(idx: number): boolean {\r\n    if (this.Rows.length <= idx || idx < 0)\r\n      return false;\r\n    let row = <Row>this.Rows.get_Item(idx);\r\n    if (row == null)\r\n      return false;\r\n    return row.Created && row.Validated;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   runs in Worker thread when the thread is free and send to GUI thread controls data of all rows\r\n  /// </summary>\r\n  async transferDataToGui(): Promise<void> {\r\n    let saveRowIdx: number = this.GetDataview().getCurrRecIdx();\r\n    let maxTime: number = Misc.getSystemMilliseconds() + MgForm.TIME_LIMIT;\r\n    let updated: boolean = false;\r\n    let currentEditingControl: MgControlBase = super.getTask().CurrentEditingControl;\r\n\r\n    try {\r\n      let bkpRecord: Record = this.GetDataview().backupCurrent();\r\n      // this limitation is needed so this request will never take too much time\r\n      while (Misc.getSystemMilliseconds() < maxTime && this.RefreshRepeatableAllowed) {\r\n        if (this._lastRowSent + 1 >= this.GetDataview().getSize()) {\r\n          this.RefreshUI();\r\n          // all rows already sent\r\n          break;\r\n        }\r\n        else if (this.isTableWithPagination() && this._lastRowSent + 1 >= this.getMaxRowsInPaginatedTable()) {\r\n          this.RefreshUI();\r\n          break;\r\n        }\r\n        this._lastRowSent++;\r\n        this._transferringDataToGUI = true;\r\n        this.AllowedSubformRecompute = false;\r\n        if (!this.isRowValidated(this._lastRowSent)) {\r\n          // row needs to be sent\r\n          // send row data\r\n          super.checkAndCreateRow(this._lastRowSent);\r\n          if (this._lastRowSent !== saveRowIdx) {\r\n            super.getTask().CurrentEditingControl = null; // reset the flag\r\n            // irrelevant for tree\r\n            await this.setCurrRowByDisplayLine(this._lastRowSent, false, true);\r\n            await super.refreshControls(true);\r\n            updated = true;\r\n          }\r\n        }\r\n        this.AllowedSubformRecompute = true;\r\n        this._transferringDataToGUI = false;\r\n      }\r\n      // restore previous current record\r\n      if (updated) {\r\n        await this.restoreBackup(saveRowIdx, bkpRecord);\r\n        await super.refreshControls(true);\r\n        super.getTask().CurrentEditingControl = currentEditingControl; // set the flag to the original value\r\n      }\r\n    }\r\n    catch (ex) {\r\n      if (ex instanceof RecordOutOfDataViewException) {\r\n        Logger.Instance.WriteDevToLog(ex.Message);\r\n      }\r\n      else\r\n        throw ex;\r\n    }\r\n    this._transferingData = false;\r\n    this.checkAndCreateRowsEvent();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if any rows need to be sent to GUI thread\r\n  ///   if there are, puts event in event queue\r\n  /// </summary>\r\n  private checkAndCreateRowsEvent(): void {\r\n    if (this._tableMgControl !== null && this.Opened && this.RefreshRepeatableAllowed) {\r\n      let size: number = this.GetDataview().getSize();\r\n      if (this._lastRowSent >= this.Rows.length) {\r\n        // when we decrease size of rows array adjust lastRowSent\r\n        this._lastRowSent = this.Rows.length - 1;\r\n      }\r\n\r\n      // there are rows to send and there is now request for rows yet\r\n      // add request for rows\r\n      let transferDataToGui: boolean = this._lastRowSent < (size - 1);\r\n\r\n      // For paginated table check the max rows of GUI table control.\r\n      if (this.isTableWithPagination() && (this._lastRowSent + 1) >= this.getMaxRowsInPaginatedTable())\r\n        transferDataToGui = false;\r\n\r\n      if (transferDataToGui && !this._transferingData) {\r\n        AccessHelper.eventsManager.addInternalEventWithCtrlAndCodeAndPriority(this._tableMgControl, InternalInterface.MG_ACT_DV_TO_GUI, Priority.LOWEST);\r\n        this._transferingData = true;\r\n      }\r\n      else if (this.shouldFetchRecordsAheadFromServer && !transferDataToGui && (!this.GetDataview().IncludesLast() || !this.GetDataview().IncludesFirst())) {\r\n        AccessHelper.eventsManager.addInternalEventWithCtrlAndCodeAndPriority(this._tableMgControl, InternalInterface.MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER, Priority.LOWEST);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   gets row data for the page\r\n  /// </summary>\r\n  /// <param name = \"desiredTopIndex\">desired top index if desiredTopIndex is Integer.MIN_VALUE, top index is cecieved form dv</param>\r\n  /// <param name = \"sendAll\">if true, send all records, even if they are created and valid</param>\r\n  /// <param name=\"lastFocusedVal\"></param>\r\n  async setRowData(desiredTopIndex: number, sendAll: boolean ): Promise<void> {\r\n    let saveRowIdx: number = this.GetDataview().getCurrRecIdx();\r\n    let diff: number = 0;\r\n    let getPrevChunk: boolean = false;\r\n    let getNextChunk: boolean = false;\r\n    let updated: boolean = false;\r\n\r\n    if (desiredTopIndex !== Int32.MinValue) {\r\n      if (desiredTopIndex < 0) {\r\n        // this is request for line or page before current chunk\r\n        // in this case the top index is always 0\r\n        getPrevChunk = true;\r\n        this.GetDataview().setTopRecIdx(0);\r\n      }\r\n      else if (desiredTopIndex + this._rowsInPage + 1 >= this.GetDataview().getSize())\r\n      // pagedown or arrowdown at end of the dataview\r\n        getNextChunk = true;\r\n    }\r\n    else\r\n      desiredTopIndex = this.GetDataview().getTopRecIdx();\r\n\r\n    let bkpRecord: Record = this.GetDataview().backupCurrent();\r\n\r\n    this._transferringDataToGUI = true;\r\n    this.AllowedSubformRecompute = false;\r\n    let diffRef: RefParam<number> = new RefParam(diff);\r\n    updated = await this.refreshRows(desiredTopIndex, sendAll, saveRowIdx, diffRef);\r\n    diff = diffRef.value;\r\n\r\n    if ((getPrevChunk && diff !== 0) || getNextChunk) {\r\n      // if diff != 0 a new chunk was brought to the begining of the dv\r\n      // set top index to first requested index\r\n      // if next chunk was brought, top index may also be updated\r\n      this.GetDataview().setTopRecIdx(desiredTopIndex + diff);\r\n      this.SetTableTopIndex();\r\n      if (this._topIndexUpdated) {\r\n        // if top index was updated in the setTableTopIndex - we might have rows that were not refreshed\r\n        this._topIndexUpdated = false;\r\n      }\r\n    }\r\n\r\n    this.AllowedSubformRecompute = true;\r\n    this._transferringDataToGUI = false;\r\n\r\n    if (updated) {\r\n      // any row was updated\r\n      // restore current record\r\n      await this.restoreBackup(saveRowIdx + diff, bkpRecord);\r\n      await super.refreshControls(true);\r\n    }\r\n    // ask table to refresh the page\r\n\r\n    super.SelectRow();\r\n    if (getPrevChunk) {\r\n      let lastFocusedControl: MgControl = LastFocusedManager.getLastFocusedControl();\r\n      // check if this is focused\r\n      if (lastFocusedControl !== null && lastFocusedControl.getParentTable() === this._tableMgControl) {\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   refreshes rows in the page\r\n  /// </summary>\r\n  /// <param name = \"desiredTopIndex\"></param>\r\n  /// <param name = \"sendAll\"></param>\r\n  /// <param name = \"saveRowIdx\"></param>\r\n  /// <param name = \"diff\"></param>\r\n  /// <returns></returns>\r\n  private async refreshRows(desiredTopIndex: number, sendAll: boolean, saveRowIdx: number, diffRef: RefParam<number>): Promise<boolean> {\r\n    let index: number = 0;\r\n    let updated: boolean = false;\r\n    diffRef.value = 0;\r\n    let orgIncludesFirst: boolean = this.GetDataview().IncludesFirst();\r\n    let orgIncludesLast: boolean = this.GetDataview().IncludesLast();\r\n    for (let i: number = 0; i < this._rowsInPage; i++) {\r\n      let idx: number = desiredTopIndex + i;\r\n      let prevTopIdx: number = this.GetDataview().getTopRecIdx();\r\n      try {\r\n        // if we fail to get one record, we may succeed to get the next one\r\n        index = idx + diffRef.value;\r\n        if (!this.isRowValidated(idx) || sendAll || this.RefreshAllRows) {\r\n          if (index >= 0)\r\n            super.checkAndCreateRow(index);\r\n\r\n          if (saveRowIdx + diffRef.value !== index) { // not current line\r\n            // irrelevant for tree\r\n            await this.setCurrRowByDisplayLine(index, false, true);\r\n            await super.refreshControls(true);\r\n          }\r\n\r\n          // if a new chunk is brought top index will be changed\r\n          updated = true;\r\n        }\r\n      }\r\n      catch (ex) {\r\n        if (ex instanceof RecordOutOfDataViewException) {\r\n          // creation of row failed, mark the row as not created\r\n          if (super.isRowCreated(index))\r\n            super.markRowNOTCreated(index);\r\n\r\n          break;\r\n        }\r\n        else\r\n          throw ex;\r\n      }\r\n      finally {\r\n        // QCR #261055, even so required record may not be found, it is possible that a new chunk has been sent\r\n        // and diff must be updated\r\n        diffRef.value = diffRef.value + (this.GetDataview().getTopRecIdx() - prevTopIdx);\r\n        prevTopIdx = this.GetDataview().getTopRecIdx();\r\n        if (!updated && this.GetDataview().DataviewBoundriesAreChanged(orgIncludesFirst, orgIncludesLast))\r\n          updated = true;\r\n      }\r\n    }\r\n    this.RefreshUI();\r\n    this.RefreshAllRows = false;\r\n    return updated;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <returns> row in the page</returns>\r\n  getVisibleLine(): number {\r\n    let currRecIdx: number = 0;\r\n    if (this.GetDataview().getCurrRecIdx() !== Int32.MinValue)\r\n      currRecIdx = this.GetDataview().getCurrRecIdx();\r\n\r\n    return currRecIdx - Math.max(this.GetDataview().getTopRecIdx(), 0);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   asserts that current record is in the view, if it is not on the page, adjusts top index, so that current\r\n  ///   record will be on the visible page\r\n  /// </summary>\r\n  async bringRecordToPage(): Promise<void> {\r\n    if (this._tableMgControl !== null && !this._task.DataView.isEmptyDataview()) {\r\n      let topIndex: number = Commands.getTopIndex(this._tableMgControl);\r\n      let currIdx: number = this.GetDataview().getCurrRecIdx();\r\n      let newTopIndex: number = topIndex;\r\n\r\n      // Table top index for non-paginated table\r\n      if (!this.isTableWithPagination()) {\r\n        if (topIndex > currIdx) {\r\n          this._topIndexUpdated = true;\r\n          newTopIndex = currIdx;\r\n        }\r\n        else if (topIndex + this._rowsInPage - 1 < currIdx) {\r\n          this._topIndexUpdated = true;\r\n          if (this._rowsInPage > 0)\r\n            newTopIndex = currIdx - this._rowsInPage + 1;\r\n          else\r\n            newTopIndex = currIdx;\r\n        }\r\n      }\r\n      else {\r\n        // Calculate the table top index for paginated table.\r\n        // This will be the index of first record on the page that contains record to be selected.\r\n        let currGuiIdx = this.getGuiRowidx(currIdx);\r\n        let newTopGuiIndex = (currGuiIdx) - ((currGuiIdx) % this._rowsInPage); //gui idx of first record of respective page\r\n\r\n        newTopIndex = this.getDvRowIdx(newTopGuiIndex);\r\n\r\n        if(newTopIndex !== this._prevGuiTopIndex || this.IsMovingInView )\r\n            this._topIndexUpdated = true;\r\n      }\r\n\r\n      // set top index to be current line\r\n      if (this.GetDataview().getTopRecIdx() !== newTopIndex || this._topIndexUpdated) {\r\n        this.GetDataview().setTopRecIdx(newTopIndex);\r\n        this.SetTableTopIndex();\r\n        await this.setRowData(Int32.MinValue, false);\r\n        this._topIndexUpdated = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   invalidate table\r\n  /// </summary>\r\n  invalidateTable(): void {\r\n    for (let i: number = 0; i < this.Rows.length; i++) {\r\n      let row: Row = <Row>this.Rows.get_Item(i);\r\n      if (row !== null)\r\n        row.Validated = false;\r\n    }\r\n\r\n    this._lastRowSent = -1;\r\n    this.checkAndCreateRowsEvent();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return previous visible line\r\n  /// </summary>\r\n  /// <param name = \"line\"></param>\r\n  /// <returns></returns>\r\n  getPrevLine(line: number): number {\r\n    return line - 1;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   This function clears the sort mark(delta) from the column.\r\n  /// </summary>\r\n  /// <param name = \"clearSortMark\"></param>\r\n  clearTableColumnSortMark(clearSortMark: boolean): void {\r\n    if (clearSortMark) {\r\n\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   This method stop the row from editing\r\n  /// </summary>\r\n  /// <param name = \"idx\"></param>\r\n  async stopRowEditing(idx: number): Promise<void> {\r\n   if (this.getIsRowEditingFromGui(idx)) {\r\n       Commands.addValueWithLine(CommandType.SET_NOT_IS_ROW_EDITING, this,  this.isLineMode()  ? idx : 0, this.isLineMode());\r\n       await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n       Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());\r\n   }\r\n  }\r\n  /// <summary>\r\n  ///   This method start the row editing\r\n  /// </summary>\r\n  /// <param name = \"idx\"></param>\r\n  async startRowEditing(idx: number): Promise<void> {\r\n      if (!this.getIsRowEditingFromGui(idx)) {\r\n          Commands.addValueWithLine(CommandType.SET_IS_ROW_EDITING, this, this.isLineMode() ? idx : 0, this.isLineMode());\r\n          await this.RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n          Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());\r\n      }\r\n  }\r\n  /// <summary>\r\n  ///   This method return if the row is in editing\r\n  /// </summary>\r\n  /// <param name = \"idx\"></param>\r\n  public getIsRowEditingFromGui(displayIndex:number ): boolean {\r\n    let isRowEditing: boolean = Commands.getIsRowEditing(this, this.isLineMode() ? displayIndex : 0, this.isLineMode());\r\n    return isRowEditing;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   update the display, the controls and their properties\r\n  /// </summary>\r\n  async RefreshDisplay(refreshType: string): Promise<boolean> {\r\n    let task: TaskBase = <TaskBase>this._task;\r\n\r\n    if (this.isFetchingRecordsAhead)\r\n      return false;\r\n\r\n    if (task.isAborting())\r\n      return false;\r\n\r\n    let currRec: Record = this.GetDataview().getCurrRec();\r\n\r\n    // Take another approach to the solution of QCRs #984999, #933639 & #699821:\r\n    // Now, the display would be refreshed only if the current record is NOT an old\r\n    // record which is being computed. The result of this change is that during the\r\n    // compute process of a record the display is not refreshed (which is good for us).\r\n    // The display would be refreshed anyway AFTER the compute process is done.\r\n    // (Ehud 21-MAY-2002)\r\n    if (currRec !== null && currRec.InCompute && !currRec.isNewRec())\r\n      return false;\r\n\r\n    if (this._inRefreshDisp)\r\n      return false;\r\n    this._inRefreshDisp = true;\r\n\r\n    try {\r\n      if (refreshType === Constants.TASK_REFRESH_FORM || refreshType === Constants.TASK_REFRESH_TABLE) {\r\n        // check if there is a table in the form and refresh it\r\n        if (super.HasTable() && this.Opened)\r\n          await this.refreshTable();\r\n      }\r\n\r\n      if (refreshType === Constants.TASK_REFRESH_FORM || refreshType === Constants.TASK_REFRESH_CURR_REC) {\r\n        if (refreshType === Constants.TASK_REFRESH_CURR_REC && super.hasTable()) {\r\n          this.SetTableTopIndex();\r\n          super.SelectRow();\r\n\r\n          await this.fetchPrevChunkForCurrentPage();\r\n        }\r\n        // refresh the form properties\r\n        await super.refreshProps();\r\n        // refresh the current record/Row\r\n        await super.refreshControls(false);\r\n      }\r\n    }\r\n    catch (ex) {\r\n      if (ex instanceof Exception) {\r\n        Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"{0} : {1} in task {2}\", ex.GetType(), ex.Message, (<TaskBase>super.getTask()).PreviouslyActiveTaskId));\r\n      }\r\n      else\r\n        throw ex;\r\n    }\r\n    finally {\r\n      this._inRefreshDisp = false;\r\n    }\r\n\r\n    // Signal we completed the first cycle of refreshing the form\r\n    if (refreshType === Constants.TASK_REFRESH_CURR_REC && (!super.isLineMode() || this._tableRefreshed))\r\n    {\r\n      this.FormRefreshed = true;\r\n\r\n      if ((<TaskBase>this._task).isFirstRecordCycle() || AccessHelper.eventsManager.getIsInViewRefresh()) {\r\n        Commands.addNoParameters(CommandType.SET_WC_IDLE, this);\r\n        AccessHelper.eventsManager.setIsInViewRefresh(false);\r\n      }\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  public RefreshUI(): void {\r\n    if (!this.getTask().isMainProg() /*&& InitializationFinished*/) {\r\n      Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   refresh forms with tables\r\n  /// </summary>\r\n  private async refreshTable(): Promise<void> {\r\n    if (this.isFetchingRecordsAhead)\r\n      return;\r\n    Logger.Instance.WriteGuiToLog(\"Start form.refreshTable()\");\r\n    // todo for now - always show all records\r\n    // save the old current row\r\n    this.updateDisplayLineByDV();\r\n    let oldCurrRow: number = this.DisplayLine;\r\n    let currRecIdx: number = this.GetDataview().getCurrRecIdx();\r\n\r\n    // For the first time we refresh the table - set curr-row and top-rec-idx to be the\r\n    // ones requested by the dataview.\r\n    // In the following table refreshes - we change curr-row and top-rec only if the table\r\n    // becomes empty.\r\n    if (!this._tableRefreshed && currRecIdx >= 0) {\r\n      oldCurrRow = this.GetDataview().getCurrRecIdx();\r\n\r\n\r\n      if (oldCurrRow + 1 > this._rowsInPage)\r\n        this.GetDataview().setTopRecIdx(oldCurrRow - Math.floor(this._rowsInPage / 2) + 1);\r\n\r\n      else\r\n        this.GetDataview().setTopRecIdx(0);\r\n    }\r\n    else {\r\n      if (oldCurrRow === Int32.MinValue)\r\n        oldCurrRow = 0;\r\n\r\n      if (this.GetDataview().getTopRecIdx() === Int32.MinValue)\r\n        this.GetDataview().setTopRecIdx(currRecIdx);\r\n    }\r\n\r\n    // When TopRecIdx < 0 it means we shold not continue the refresh since we are in temporary situation.\r\n    // Another refresh will be done soon with correct values.\r\n    // This is can happen when :\r\n    // In fetchChunkFromServer we go to the server and the client expects new records.\r\n    // While in the process of fetchingChunk, we might go again to the server, before the server sends us the chunk.\r\n    // Going to the server in the get chunk process , can be for example: record suffix, or any server side op in rec suff or VC.\r\n    // Usually, during this part, we do not refresh the table.\r\n    // But, for example in QCR #698217, a call was made to refreshTable with TopRecIdx == -1.\r\n    // The reason was, that in the VC there was a server op that updated a var in the task. As a result, the 'modi' flag\r\n    // from the server was on, which caused the \"temp\" refreshTable before the real chunk arrived.\r\n    // This in turn caused a change in the curr rec id, which was wrong.\r\n    // After the chunk arrives, the refresh sets the correct values.\r\n    if (this.GetDataview().getTopRecIdx() < 0)\r\n      return;\r\n\r\n    oldCurrRow = oldCurrRow - this.GetDataview().getTopRecIdx(); // save oldCurrRow relatively to the top index\r\n    let bkpRecord: Record = this.GetDataview().backupCurrent();\r\n    this._tableRefreshed = true;\r\n\r\n    let oriTransferDataToGui = this._transferringDataToGUI;\r\n\r\n    if (!oriTransferDataToGui)\r\n      this._transferringDataToGUI = true;\r\n    this.AllowedSubformRecompute = false;\r\n    // QCR #998067, we must not refresh subforms for any rows that are not our real current row\r\n\r\n    // refresh all the rows BUT not the old current row\r\n    for (let i: number = 0; i < this._rowsInPage; i++) {\r\n      // when there is no record for a row just disable it and vice versa\r\n      let topIndex: number = this.GetDataview().getTopRecIdx();\r\n      if (topIndex < 0) {\r\n        this.GetDataview().setTopRecIdx(0);\r\n        topIndex = 0;\r\n      }\r\n      let idx: number = topIndex + i;\r\n      try {\r\n        super.checkAndCreateRow(idx);\r\n\r\n        // skip the old current row. the refresh for this row is done by the caller\r\n        // and refresh only valid lines that were not disabled\r\n        if (i !== oldCurrRow) {\r\n          await this.setCurrRowByDisplayLine(idx, false, true);\r\n          await super.refreshControls(true);\r\n        }\r\n      }\r\n      catch (ex) {\r\n        if (ex.name == \"RecordOutOfDataViewException\") {\r\n          // creation of row failed, mark the row as not created\r\n          if (super.isRowCreated(idx))\r\n            super.markRowNOTCreated(idx);\r\n          break;\r\n        }\r\n        else\r\n          throw ex;\r\n      }\r\n    }\r\n    this.AllowedSubformRecompute = true;\r\n    if (!oriTransferDataToGui)\r\n      this._transferringDataToGUI = false;\r\n    await this.restoreBackup(oldCurrRow + this.GetDataview().getTopRecIdx(), bkpRecord);\r\n    await super.refreshControls(true);\r\n    this.RefreshUI();\r\n    Logger.Instance.WriteGuiToLog(\"End form.refreshTable()\");\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set display line by record line\r\n  /// </summary>\r\n  updateDisplayLineByDV(): void {\r\n    this.DisplayLine = this.recordIdx2DisplayLine(this.GetDataview().getCurrRecIdx());\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the current row\r\n  /// </summary>\r\n  /// <param name = \"displayLine\">is the new current display line</param>\r\n  /// <param name = \"doSuffix\">do the record suffix for the previous record</param>\r\n  /// <param name = \"ignoreCurrRec\">do the actions as if there is no current record</param>\r\n  async setCurrRowByDisplayLine(displayLine: number, doSuffix: boolean, ignoreCurrRec: boolean): Promise<void> {\r\n    let recIdx: number = this.displayLine2RecordIdx(displayLine);\r\n    await this.setCurrRowByRecIdx(recIdx, doSuffix, ignoreCurrRec, displayLine);\r\n    if (super.HasTable())\r\n      this.updateDisplayLineByDV();\r\n    else\r\n      this.DisplayLine = displayLine;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the current row\r\n  /// </summary>\r\n  /// <param name = \"rowNum\">is the new current row number</param>\r\n  /// <param name = \"doSuffix\">do the record suffix for the previous record</param>\r\n  /// <param name = \"ignoreCurrRec\">do the actions as if there is no current record</param>\r\n  private async setCurrRowByRecIdx(rowNum: number, doSuffix: boolean, ignoreCurrRec: boolean, displayLine: number): Promise<void> {\r\n    if (this.GetDataview() === null || (!super.hasTable() && rowNum !== 0))\r\n      throw new ApplicationException(\"in Form.setCurrRow() no table \");\r\n\r\n    try {\r\n      this._destTblRow = rowNum;\r\n      await this.GetDataview().setCurrRecByIdx(rowNum, doSuffix, ignoreCurrRec, true, displayLine);\r\n    }\r\n    finally {\r\n      this._destTblRow = rowNum - this.GetDataview().getTopRecIdx();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the last valid row in the table\r\n  /// </summary>\r\n  getLastValidRow(): number {\r\n    return Math.min(this._rowsInPage - 1, this.GetDataview().getSize() - 1 - this.GetDataview().getTopRecIdx());\r\n  }\r\n\r\n  /// <summary>\r\n  ///   translate record line to display line\r\n  /// </summary>\r\n  /// <param name = \"recIdx\"></param>\r\n  /// <returns></returns>\r\n  recordIdx2DisplayLine(recIdx: number): number {\r\n    return recIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   translate display line to record line\r\n  /// </summary>\r\n  /// <param name = \"displayLine\"></param>\r\n  /// <returns></returns>\r\n  displayLine2RecordIdx(displayLine: number): number {\r\n    return displayLine;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   restore the old current row using the parameter and ignoring any exception\r\n  /// </summary>\r\n  /// <param name = \"displayLine\">the old current row number to be restored</param>\r\n  async restoreOldDisplayLine(displayLine: number): Promise<void> {\r\n    try {\r\n      this._inRestore = true;\r\n      await this.setCurrRowByDisplayLine(displayLine, false, true);\r\n    }\r\n    catch (ex) {\r\n      if (ex instanceof RecordOutOfDataViewException) {\r\n      }\r\n      else\r\n        throw ex;\r\n    }\r\n    finally {\r\n      this._inRestore = false;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   gets record from gui level\r\n  /// </summary>\r\n  getTopIndexFromGUI(): number {\r\n    let topDisplayLine: number = super.getTopIndexFromGUI();\r\n\r\n    if (super.hasTable())\r\n      this.GetDataview().setTopRecIdx(this.displayLine2RecordIdx(topDisplayLine));\r\n\r\n    return topDisplayLine;\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns the current record position in the form.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getCurrRecPosInForm(): number {\r\n    // when the selected record is outside the view, topIndex and DisplayLine will be 0\r\n    // resulting in currRecPosInForm == 1\r\n    let topDisplayLine: number = super.getTopIndexFromGUI();\r\n    return this.DisplayLine - topDisplayLine + 1;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   restores current record\r\n  /// </summary>\r\n  /// <param name = \"oldDisplayLine\">old current record idx</param>\r\n  /// <param name = \"bkpRecord\">saved record</param>\r\n  async restoreBackup(oldDisplayLine: number, bkpRecord: Record): Promise<void> {\r\n    // QCR #942878, if record is in process of insert, delete or modify we must perform restoreOldCurrRow\r\n    // that will perform all necessary actions for the record, otherwise we can just restore it from backup\r\n    if (bkpRecord.getId() >= 0 && this.GetDataview().getRecIdx(bkpRecord.getId()) >= 0 && oldDisplayLine >= 0 && oldDisplayLine < this.GetDataview().getSize() && this.GetDataview().getCurrRecIdx() >= 0 && bkpRecord.getMode() === DataModificationTypes.None) {\r\n      this.GetDataview().restoreCurrent(bkpRecord);\r\n      this.updateDisplayLineByDV();\r\n    }\r\n    else\r\n      await this.restoreOldDisplayLine(oldDisplayLine);\r\n  }\r\n\r\n  ConstructMgControl(): MgControlBase;\r\n  ConstructMgControl(type: MgControlType, task: TaskBase, parentControl: number): MgControlBase;\r\n  ConstructMgControl(type: MgControlType, parentMgForm: MgFormBase, parentControlIdx: number): MgControlBase;\r\n  ConstructMgControl(type?: MgControlType, taskOrParentMgForm?: any, parentControlOrParentControlIdx?: number): MgControlBase {\r\n    if (arguments.length === 0) {\r\n      return this.ConstructMgControl_0();\r\n    }\r\n    if (arguments.length === 3 && (type === null || type.constructor === Number) && (taskOrParentMgForm === null || taskOrParentMgForm instanceof TaskBase) && (parentControlOrParentControlIdx === null || parentControlOrParentControlIdx.constructor === Number)) {\r\n      return this.ConstructMgControl_1(type, taskOrParentMgForm, parentControlOrParentControlIdx);\r\n    }\r\n    return this.ConstructMgControl_2(type, taskOrParentMgForm, parentControlOrParentControlIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  /// constructs an object of MgControl\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private ConstructMgControl_0(): MgControlBase {\r\n    return new MgControl();\r\n  }\r\n\r\n  /// <summary>\r\n  /// constructs an object of MgControl\r\n  /// </summary>\r\n  /// <param name=\"type\"></param>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"parentControl\"></param>\r\n  /// <returns></returns>\r\n  private ConstructMgControl_1(type: MgControlType, task: TaskBase, parentControl: number): MgControlBase {\r\n    return new MgControl(type, task, parentControl);\r\n  }\r\n\r\n  /// <summary>constructs an object of MgControl</summary>\r\n  /// <param name=\"type\"></param>\r\n  /// <param name=\"parentMgForm\"></param>\r\n  /// <param name=\"parentControlIdx\"></param>\r\n  /// <returns></returns>\r\n  private ConstructMgControl_2(type: MgControlType, parentMgForm: MgFormBase, parentControlIdx: number): MgControlBase {\r\n    return new MgControl(type, parentMgForm, parentControlIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Returns true if already moved to the first control on one of the MgData\r\n  /// </summary>\r\n  alreadyMovedToFirstControl(): boolean {\r\n    return (<TaskBase>this._task).getMGData().AlreadyMovedToFirstControl();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   refresh table first time we enter the ownerTask\r\n  ///   get rows number form gui level\r\n  /// </summary>\r\n  async firstTableRefresh(): Promise<void> {\r\n    if (this._tableMgControl !== null) {\r\n      super.firstTableRefresh();\r\n      this.setTableItemsCount(false);\r\n      await this.refreshTable();\r\n      super.SelectRow();\r\n    }\r\n  }\r\n\r\n  InsertTableItems(idx: number, count: number): void {\r\n    if (this._tableMgControl != null) {\r\n      this.Rows.InsertRange(new Array(count));\r\n      this.InsertTableChildrenArrays(idx, count);\r\n      this._lastRowSent = -1;\r\n    }\r\n\r\n    this.setTableItemsCount(false);\r\n  }\r\n\r\n/// <summary>\r\n  ///   update table item's count according to dataview\r\n  /// </summary>\r\n   setTableItemsCount(removeAll: boolean): void {\r\n    let tableItemsCount: number;\r\n\r\n    // For absolute scrollbar, set the virtual items count accordingly.\r\n    if (this.isTableWithAbsoluteScrollbar()) {\r\n\r\n      // If task is moved into CREATE mode and currently new line is created\r\n      // then only newly created records should be see on the screen\r\n      if ((<TaskBase>this._task).getOriginalTaskMode() === Constants.TASK_MODE_CREATE\r\n          && this._task.getMode() == Constants.TASK_MODE_CREATE) {\r\n\r\n        tableItemsCount = this.GetDataview().getSize();\r\n\r\n        // Reset recordsBeforeCurrentView\r\n        if (this.GetDataview().RecordsBeforeCurrentView > 0) {\r\n          this.GetDataview().RecordsBeforeCurrentView = 0;\r\n          this.SetRecordsBeforeCurrentView(0);\r\n          this.RefreshUI();\r\n        }\r\n      }\r\n      else {\r\n        // Table with set of records OR if empty table then tableItemsCount should not be 0, as we always have 0th row.\r\n        tableItemsCount = (this.GetDataview().TotalRecordsCount > 0) ? this.GetDataview().TotalRecordsCount: 1;\r\n        this.SetRecordsBeforeCurrentView(this.GetDataview().RecordsBeforeCurrentView);\r\n      }\r\n    }\r\n    else {\r\n      // Non-paginated table\r\n      tableItemsCount = this.GetDataview().getSize();\r\n    }\r\n\r\n     super.SetTableItemsCount(this.GetDataview().getSize(), tableItemsCount, removeAll);\r\n  }\r\n\r\n\r\n  InitTableControl(): void;\r\n  InitTableControl(dvSize: number, tableItemsCount: number, removeAll: boolean): void;\r\n  InitTableControl(dvSize?: number, tableItemsCount?: number, removeAll?: boolean): void {\r\n    if (arguments.length === 0) {\r\n      this.InitTableControl_00();\r\n      return;\r\n    }\r\n    this.InitTableControl_01(dvSize, tableItemsCount, removeAll);\r\n  }\r\n\r\n  /// <summary>\r\n  /// inits the table control\r\n  /// </summary>\r\n  private InitTableControl_00(): void {\r\n    let dvSize: number = 1;\r\n    let tableItemsCount: number = 1;\r\n\r\n    // Initializing the table control for the first time while creating the form with totalRecordsCount and also\r\n    // set the recordsBeforeCurrentView, in order to create the first row at respective location in case of locate.\r\n    if (this.isTableWithAbsoluteScrollbar() && this.GetDataview().TotalRecordsCount > 0) {\r\n      let recordsBeforeCurrentView: number = this.GetDataview().RecordsBeforeCurrentView;\r\n      tableItemsCount = this.GetDataview().TotalRecordsCount;\r\n      Commands.addWithNumber(CommandType.SET_RECORDS_BEFORE_CURRENT_VIEW, this._tableMgControl, recordsBeforeCurrentView);\r\n    }\r\n\r\n    this.InitTableControl(dvSize, tableItemsCount, false);\r\n    this.SetTableTopIndex();\r\n  }\r\n\r\n  /// <summary>\r\n  /// inits table control's rows to 'tableItemsCount' count\r\n  /// </summary>\r\n  /// <param name=\"dvSize\"></param>\r\n  /// <param name=\"tableItemsCount\"></param>\r\n  /// <param name=\"removeAll\"></param>\r\n  private InitTableControl_01(dvSize: number, tableItemsCount: number, removeAll: boolean): void {\r\n    if (this._tableMgControl !== null) {\r\n      if (removeAll) {\r\n        Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_FIRST, this._tableMgControl, 0, true);\r\n        Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_LAST, this._tableMgControl, 0, true);\r\n      }\r\n      else {\r\n        Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_FIRST, this._tableMgControl, 0, this.GetDataview().IncludesFirst() || this.GetDataview().IsOneWayKey);\r\n        Commands.addBoolWithLine(CommandType.SET_TABLE_INCLUDES_LAST, this._tableMgControl, 0, this.GetDataview().IncludesLast());\r\n        Commands.addBoolWithLine(CommandType.SET_EMPTY_DATAVIEW, this._tableMgControl, 0, this.GetDataview().isEmptyDataview());\r\n      }\r\n\r\n      super.InitTableControl(dvSize, tableItemsCount, removeAll);\r\n\r\n      this.checkAndCreateRowsEvent();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set top index\r\n  /// </summary>\r\n  SetTableTopIndex(): void {\r\n    if (this._tableMgControl !== null) {\r\n      let index: number = this.GetDataview().getTopRecIdx();\r\n      if (index === Int32.MinValue)\r\n        index = 0;\r\n\r\n      if (!this.isTableWithPagination()) {\r\n        if (this.GetDataview().IncludesLast()) {\r\n          // table now behaves like listview, it can not show empty lines\r\n          // so we must update top index\r\n          if (index + this._rowsInPage > this.GetDataview().getSize()) {\r\n            // but we do show empty lines if includeFirst = false\r\n            // and we have less records then rows on screen QCR #!!!!!!\r\n            if (this.GetDataview().IncludesFirst() || this.GetDataview().getSize() > this._rowsInPage + 1) {\r\n              index = Math.max(this.GetDataview().getSize() - this._rowsInPage, 0);\r\n              this.GetDataview().setTopRecIdx(index);\r\n              this._topIndexUpdated = true;\r\n            }\r\n          }\r\n        }\r\n      }\r\n      if (index !== this._prevGuiTopIndex || this.IsMovingInView) {\r\n        Commands.addWithNumber(CommandType.SET_TABLE_TOP_INDEX, this._tableMgControl, index);\r\n        this._prevGuiTopIndex = this.getGuiRowidx(index);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Creates the window defined by this form and its child controls\r\n  /// </summary>\r\n  async createForm(): Promise<void> {\r\n    await super.createForm();\r\n    MgForm.CreatedForms.add(this);\r\n  }\r\n\r\n\r\n  /// <summary>Writes the string or sets the image on the pane with the specified index.</summary>\r\n  /// <param name=\"paneIdx\">Index of the pane to be updated</param>\r\n  /// <param name=\"strInfo\">Message</param>\r\n  /// <param name=\"soundBeep\">Sound beep or not</param>\r\n  UpdateStatusBar(): void {\r\n    // TODO: implement in WebClient.\r\n    // if (paneIdx == Constants.SB_MSG_PANE_LAYER || Environment.Instance.getSpecialShowStatusBarPanes())\r\n    //   base.UpdateStatusBar(paneIdx, strInfo, soundBeep);\r\n  }\r\n\r\n  /// <summary>\r\n  /// init the recompute table for that form\r\n  /// </summary>\r\n  /// <param name=\"foundTagName\"></param>\r\n  /// <returns></returns>\r\n  initInnerObjects(foundTagName: string): boolean {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    let parser: XmlParser = Manager.GetCurrentRuntimeContext().Parser;\r\n    if (foundTagName === XMLConstants.MG_TAG_RECOMPUTE) {\r\n      Logger.Instance.WriteDevToLog(\"goes to recompute form\");\r\n      (<TaskBase>this._task).RecomputeFillData(parser);\r\n      return true;\r\n    }\r\n    return super.initInnerObjects(foundTagName);\r\n  }\r\n\r\n  toString(): string {\r\n    return \"{\" + this.constructor.name + \": task=\" + this._task + \", Id=\" + this._userStateId + \"}\";\r\n  }\r\n\r\n  /// <summary>\r\n  /// build the XML entry of the hidden controls\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetHiddenControlListXML(): string {\r\n    let xml: StringBuilder = new StringBuilder();\r\n\r\n    if (this.hiddenControlsIsnsList !== null && this.hiddenControlsIsnsList.length > 0) {\r\n      // write the id\r\n      xml.Append(\"<\" + ConstInterface.MG_TAG_HIDDEN_CONTOLS + \" \" + ConstInterface.MG_ATTR_ISNS + \"=\\\"\");\r\n\r\n      this.hiddenControlsIsnsList.forEach((change: number) => {\r\n        xml.Append(change + \",\");\r\n      });\r\n\r\n      xml.Remove(xml.Length - 1, 1);\r\n\r\n      xml.Append(\"\\\"/>\");\r\n\r\n      this.hiddenControlsIsnsList = null;\r\n    }\r\n    return xml.ToString();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Should this form behave as Modal although its WindowType != Modal?\r\n  /// For RIA, Non Interactive task's and its all child task should behave as a Modal.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  ShouldBehaveAsModal(): boolean {\r\n    let shouldBeModal: boolean = false;\r\n    // QCR #802495, non interactive tasks and its children will be opened using show dialog to prevent events on their ancestors\r\n    if (!this._task.IsInteractive && !this._task.isMainProg())\r\n      shouldBeModal = TaskBase.ShouldNonInteractiveBeModal();\r\n    else {\r\n      let parentTask: TaskBase = (<TaskBase>this._task).ParentTask;\r\n      if (parentTask !== null && !parentTask.IsInteractive && !parentTask.isMainProg())\r\n        shouldBeModal = parentTask.ShouldNonInteractiveChildBeModal();\r\n    }\r\n\r\n    return shouldBeModal;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Check whether a paginated table being used.\r\n  /// </summary>\r\n  isTableWithPagination(): boolean {\r\n    return this.isTableWithAbsoluteScrollbar();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Check whether table being used with absolute scrollbar thumb.\r\n  /// </summary>\r\n  isTableWithAbsoluteScrollbar(): boolean {\r\n    let tableWithAbsoluteScrollbar: boolean = false;\r\n    if (this._tableMgControl !== null)\r\n      tableWithAbsoluteScrollbar = (<MgControl>this._tableMgControl).IsTableWithAbsoluteScrollbar();\r\n\r\n    return tableWithAbsoluteScrollbar;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Update recordsBeforeCurrentView\r\n  /// </summary>\r\n  /// <param name=\"value\"></param>\r\n  private SetRecordsBeforeCurrentView(value: number): void {\r\n    if (this._tableMgControl !== null) {\r\n      Commands.addWithNumber(CommandType.SET_RECORDS_BEFORE_CURRENT_VIEW, this._tableMgControl, value);\r\n    }\r\n  }\r\n\r\n  buildFormName(): string {\r\n    let name: string =  this.UniqueName;\r\n    let task: TaskBase = <TaskBase>this.getTask();\r\n\r\n    name = (task.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue() + '_' + name;\r\n    while (task.IsSubtask) {\r\n      task = <TaskBase>task.StudioParentTask;\r\n      name = (task.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue() + '_' + name;\r\n    }\r\n\r\n    name = name.replace(/ /g, \"_\");\r\n    name = name.replace(/-/g, \"_\");\r\n    return name;\r\n  }\r\n\r\n  /// <summary>\r\n  /// fetchPrevChunkForCurrentPage() : To fetch previous chunk of records if needed.\r\n  /// </summary>\r\n  private async fetchPrevChunkForCurrentPage(): Promise<void> {\r\n    if (this.isTableWithAbsoluteScrollbar() && this.GetDataview().TotalRecordsCount > 0) {\r\n      let recPosOnPage: number = this.GetDataview().RecordsBeforeCurrentView % this._rowsInPage;\r\n\r\n      // If record is not the first record on page, fetch previous record for that page.\r\n      // TODO : this.DisplayLine - Check whether can be removed ?\r\n      if (recPosOnPage > 0 && this.DisplayLine === 0) {\r\n        await this.setRowData(-recPosOnPage, false);\r\n      }\r\n    }\r\n  }\r\n\r\n  getGuiRowidx(dvRowIdx: number): number {\r\n    return dvRowIdx + this.GetDataview().RecordsBeforeCurrentView;\r\n  }\r\n\r\n  getDvRowIdx(guiRowIdx: number): number {\r\n    return guiRowIdx - this.GetDataview().RecordsBeforeCurrentView;\r\n  }\r\n}\r\n"]}