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

package/esm2022/src/data/Field.mjs

@@ -0,0 +1,646 @@
+import { ApplicationException, Debug, List, NNumber, NString, RefParam, isNullOrUndefined } from "@magic-xpa/mscorelib";
+import { Constants, InternalInterface, Logger, MsgInterface, PICInterface, StorageAttribute, StrUtil, UtilStrByteMode, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { BlobType, DisplayConvertor, ExpVal, FieldDef, NUM_TYPE, PIC, VectorType } from "@magic-xpa/gui";
+import { YesNoExp } from "../exp/YesNoExp";
+import { ExpressionEvaluator } from "../exp/ExpressionEvaluator";
+import { Recompute, Recompute_RcmpBy } from "../rt/Recompute";
+import { Boundary } from "../rt/Boundary";
+import { ArgumentsList } from "../rt/ArgumentsList";
+import { ConstInterface } from "../ConstInterface";
+import { RunTimeEvent } from "../event/RunTimeEvent";
+import { Record } from "./Record";
+import { Environment } from "../env/Environment";
+import { FieldBase } from "./FieldBase";
+import { LastFocusedManager } from "../rt/LastFocusedManager";
+import { LanguageData } from "../env/LanguageData";
+import { AccessHelper } from "../AccessHelper";
+export class Field extends FieldBase {
+    static LEAVE_FLAGS = false;
+    static NUM0 = null;
+    static NUM1 = null;
+    _linkExp = null;
+    _recompute = null;
+    CacheTableFldIdx = 0;
+    _causeTableInvalidation = false;
+    _form = null;
+    _hasChangeEvent = false;
+    _hasZoomHandler = false;
+    _inEvalProcess = false;
+    _initExp = null;
+    _invalidValue = true;
+    _isLinkFld = false;
+    _isVirtual = false;
+    _dataviewHeaderId = -1;
+    _linkCreate = false;
+    Locate = null;
+    Range = null;
+    _isParam = false;
+    _isExposedRouteParam = false;
+    _isExposedToClient = true;
+    _prevIsNull = false;
+    _prevValue = null;
+    _tableName = null;
+    _indexInTable = -1;
+    _virAsReal = false;
+    _val = null;
+    modifiedAtLeastOnce = false;
+    _isNull = false;
+    _clearVectorType = true;
+    _vectorType = null;
+    static _variableChangeEvts = new List();
+    constructor(dataview, id) {
+        super(id);
+        if (Field.NUM0 === null) {
+            Field.NUM0 = new NUM_TYPE();
+            Field.NUM1 = new NUM_TYPE();
+            Field.NUM0.NUM_4_LONG(0);
+            Field.NUM1.NUM_4_LONG(1);
+        }
+        this._dataview = dataview;
+        this._linkExp = new YesNoExp(false);
+        FieldDef._default_date = DisplayConvertor.Instance.disp2mg(PICInterface.DEFAULT_DATE, new PIC("6", StorageAttribute.NUMERIC, super.getTask().getCompIdx()), super.getTask().getCompIdx(), BlobType.CONTENT_TYPE_UNKNOWN);
+    }
+    get VirAsReal() {
+        return this._virAsReal;
+    }
+    get IsVirtual() {
+        return this._isVirtual;
+    }
+    get IsExposedRouteParam() {
+        return this._isExposedRouteParam;
+    }
+    get IsExposedToClient() {
+        return this._isExposedToClient;
+    }
+    get IndexInTable() {
+        return this._indexInTable;
+    }
+    setAttribute(attribute, valueStr) {
+        let isTagProcessed = super.setAttribute(attribute, valueStr);
+        if (!isTagProcessed) {
+            let data = StrUtil.tokenize(valueStr, ",");
+            isTagProcessed = true;
+            switch (attribute) {
+                case ConstInterface.MG_ATTR_VIRTUAL:
+                    this._isVirtual = (XmlParser.getInt(valueStr) !== 0);
+                    break;
+                case ConstInterface.MG_ATTR_PARAM:
+                    this._isParam = (XmlParser.getInt(valueStr) !== 0);
+                    if (!this._isVirtual && this._isParam)
+                        throw new ApplicationException("in Field.initElements(): non virtual field is defined as a parameter");
+                    break;
+                case ConstInterface.MG_ATTR_EXPOSED_ROUTE_PARAMS:
+                    this._isExposedRouteParam = (XmlParser.getInt(valueStr) !== 0);
+                    if (!this._isParam && this._isExposedRouteParam)
+                        throw new ApplicationException("in Field.initElements(): non parameter field is defined as a exposed route parameter");
+                    break;
+                case ConstInterface.MG_ATTR_EXPOSED_TO_CLIENT:
+                    if (XmlParser.getInt(valueStr) == 0)
+                        this._isExposedToClient = false;
+                    break;
+                case ConstInterface.MG_ATTR_VIR_AS_REAL:
+                    this._virAsReal = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_LNK_CREATE:
+                    this._linkCreate = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_LNKEXP:
+                    this._linkExp.setVal((this.getTask()), valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_TABLE_NAME:
+                    this._tableName = XmlParser.unescape(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_INDEX_IN_TABLE:
+                    this._indexInTable = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_INIT:
+                    let expNum = XmlParser.getInt(valueStr);
+                    this._initExp = this.getTask().getExpById(expNum);
+                    break;
+                case XMLConstants.MG_ATTR_NAME:
+                    {
+                    }
+                    break;
+                case ConstInterface.MG_ATTR_CHACHED_FLD_ID:
+                    if (data[0] != "")
+                        this.CacheTableFldIdx = NNumber.Parse(data[1]);
+                    break;
+                case ConstInterface.MG_ATTR_LOCATE:
+                    this.Locate = new Boundary(this.getTask(), NNumber.Parse(data[1]), NNumber.Parse(data[0]), this.getType(), this.getSize(), this.CacheTableFldIdx);
+                    break;
+                case ConstInterface.MG_ATTR_RANGE:
+                    this.Range = new Boundary(this.getTask(), NNumber.Parse(data[1]), NNumber.Parse(data[0]), this.getType(), this.getSize(), this.CacheTableFldIdx);
+                    break;
+                case ConstInterface.MG_ATTR_LINK:
+                    this._dataviewHeaderId = NNumber.Parse(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_IS_LINK_FIELD:
+                    this._isLinkFld = XmlParser.getBoolean(valueStr);
+                    break;
+                default:
+                    isTagProcessed = false;
+                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+                    break;
+            }
+        }
+        return isTagProcessed;
+    }
+    setRecompute(recompRef) {
+        this._recompute = recompRef;
+    }
+    RemoveSubformFromRecompute(subformTask) {
+        if (this._recompute !== null) {
+            this._recompute.RemoveSubform(subformTask);
+        }
+    }
+    AddSubformRecompute(subformTask) {
+        if (this._recompute === null) {
+            this._recompute = new Recompute();
+            this._recompute.Task = super.getTask();
+            this._recompute.OwnerFld = this;
+            this._recompute.RcmpMode = Recompute_RcmpBy.CLIENT;
+        }
+        this._recompute.AddSubform(subformTask);
+    }
+    SetControl(ctrl) {
+        super.SetControl(ctrl);
+        if (this._isVirtual && ctrl.IsRepeatable && this._initExp === null) {
+            this._causeTableInvalidation = true;
+        }
+    }
+    async compute(recompute) {
+        let result = new RefParam(this.getValue(false));
+        let isNullFld = new RefParam(this._isNull);
+        let rec = this._dataview.getCurrRec();
+        let task = super.getTask();
+        let zeroReal = this._linkCreate && rec.InCompute && !recompute && task.getMode() === Constants.TASK_MODE_CREATE;
+        if (this._form == null)
+            this._form = task.getForm();
+        if ((this._form != null && this._form.InRestore) || AccessHelper.eventsManager.GetStopExecutionFlag())
+            zeroReal = false;
+        let rtEvt = AccessHelper.eventsManager.getLastRtEvent();
+        let computeOnCancelEvent = false;
+        if (rtEvt != null)
+            computeOnCancelEvent = rtEvt.getInternalCode() === InternalInterface.MG_ACT_CANCEL;
+        if (!this._virAsReal && (this._form == null || !this._form.InRestore) &&
+            ((this._isVirtual || (task.getMode() === Constants.TASK_MODE_CREATE && computeOnCancelEvent)) || recompute ||
+                zeroReal || rec.isNewRec() && !rec.isComputed())) {
+            if (!task.DataView.isEmptyDataview() || (task.DataView.isEmptyDataview() && !this.PartOfDataview)) {
+                if ((this._isVirtual || task.getMode() === Constants.TASK_MODE_CREATE) || this._dataview.computeByClient() ||
+                    !rec.InCompute || zeroReal || rec.lateCompute()) {
+                    if (this._initExp != null) {
+                        await this.EvaluateInitExpression(result, isNullFld);
+                    }
+                    else if (zeroReal)
+                        result.value = this.getDefaultValue();
+                }
+            }
+        }
+        if (this._invalidValue) {
+            this._prevValue = result.value;
+            this._prevIsNull = isNullFld.value;
+        }
+        await this.setValue(result.value, isNullFld.value, recompute, false, recompute && !this._isVirtual, false, false);
+    }
+    async EvaluateInitExpression(result, isNullFld) {
+        Debug.Assert(this._initExp !== null);
+        try {
+            this._inEvalProcess = true;
+            result.value = await this._initExp.evaluateWithResultTypeAndLength(this._type, this._size);
+        }
+        finally {
+            this._inEvalProcess = false;
+        }
+        isNullFld.value = (result.value === null);
+        if (isNullFld.value && this.NullAllowed) {
+            result.value = this.getValue(false);
+        }
+    }
+    getValue(checkNullArithmetic) {
+        if (super.getTask().getEvalOldValues())
+            return this.getOriginalValue();
+        if (this._invalidValue)
+            this.takeValFromRec();
+        if (this._isNull)
+            this._val = this.getValueForNull(checkNullArithmetic);
+        return this._val;
+    }
+    isChanged(newValue, isNull) {
+        return this._prevValue !== null && (!(this._prevValue === newValue) || this._prevIsNull !== isNull);
+    }
+    takeValFromRec() {
+        let rec = this._dataview.getCurrRec();
+        if (rec !== null) {
+            this._val = rec.GetFieldValue(this._id);
+            this._isNull = rec.IsNull(this._id);
+        }
+        if (this._invalidValue) {
+            if (rec !== null && this._causeTableInvalidation && this.isChanged(this._val, this._isNull) && this._form !== null) {
+                rec.setCauseInvalidation(true);
+            }
+            this._prevValue = this._val;
+            this._prevIsNull = this._isNull;
+            this._invalidValue = false;
+        }
+        this._vectorType = null;
+    }
+    getOriginalValue() {
+        let originalRec = this._dataview.getOriginalRec();
+        if (originalRec.IsNull(this._id))
+            return this.getMagicDefaultValue();
+        return originalRec.GetFieldValue(this._id);
+    }
+    isOriginalValueNull() {
+        let originalRec = this._dataview.getOriginalRec();
+        return originalRec.IsNull(this._id);
+    }
+    getValueByRecIdx(idx) {
+        let rec = this._dataview.getRecByIdx(idx);
+        let fieldValue = rec.GetFieldValue(this._id);
+        return rec.IsNull(this._id) ? this.getValueForNull(false) : fieldValue;
+    }
+    getModifiedAtLeastOnce() {
+        return this.modifiedAtLeastOnce;
+    }
+    isNullByRecIdx(idx) {
+        let rec = this._dataview.getRecByIdx(idx);
+        return rec.IsNull(this._id);
+    }
+    isEqual(mgValue, isNullFld, type, recIdx) {
+        let rec = (this._dataview.getRecByIdx(recIdx));
+        let valsEqual = false;
+        if (rec != null) {
+            let fieldValue = rec.GetFieldValue(this._id);
+            let fielsIsNull = rec.IsNull(this._id);
+            valsEqual = ExpressionEvaluator.mgValsEqual(fieldValue, fielsIsNull, this._type, mgValue, isNullFld, type);
+        }
+        return valsEqual;
+    }
+    getNewRecValue(clobberedOnly) {
+        if (this._isVirtual && this._initExp == null)
+            return this._val;
+        return !clobberedOnly ? this.getDefaultValue() : null;
+    }
+    async setValueAndStartRecompute(val, isNullFld, recompute, setRecordUpdated, isArgUpdate, enforceVariableChange) {
+        if (isNullOrUndefined(enforceVariableChange))
+            enforceVariableChange = false;
+        await this.setValueAndStartRecompute_1(val, isNullFld, recompute, setRecordUpdated, isArgUpdate, false);
+    }
+    async setValueAndStartRecompute_1(val, isNullFld, recompute, setRecordUpdated, isArgUpdate, enforceVariableChange) {
+        let task = this.getTask();
+        if (task != null)
+            task.VewFirst++;
+        let valueWasUpdated = await this.setValue(val, isNullFld, recompute, setRecordUpdated, !this._isVirtual, isArgUpdate, enforceVariableChange);
+        if (task !== null && task.VewFirst === 1 && this._form !== null && !this.IsEventHandlerField) {
+            if (recompute && valueWasUpdated)
+                await this._form.refreshOnExpressions();
+        }
+        if (task != null)
+            task.VewFirst--;
+    }
+    async setValue(newVal, isNullFld, recompute, setRecordModified, setCrsrModified, isArgUpdate, enforceValiableChange) {
+        let rec;
+        let recFldVal;
+        let valsEqual = false;
+        let remainder;
+        let zeroReal;
+        let args = null;
+        let mainCtrl = this.getCtrl();
+        let pendingEvents;
+        let evts;
+        let forceUpdate = false;
+        let checkForVariableChange = recompute || enforceValiableChange;
+        let task = this.getTask();
+        if (this._form === null)
+            this._form = task.getForm();
+        if (isNullFld && !this.NullAllowed && this._type !== StorageAttribute.BLOB_VECTOR) {
+            newVal = this.getDefaultValue();
+            isNullFld = false;
+        }
+        if (this._type === StorageAttribute.NUMERIC && newVal != null && !NUM_TYPE.numHexStrIsLong(newVal)) {
+            let numVal = new NUM_TYPE(newVal);
+            let pic = new PIC(this._picture, this._type, super.getTask().getCompIdx());
+            let decs = pic.getDec();
+            numVal.round(decs);
+            newVal = numVal.toXMLrecord();
+        }
+        rec = this._dataview.getCurrRec();
+        if (rec == null)
+            throw new ApplicationException(LanguageData.Instance.getConstMessage(MsgInterface.RT_STR_NO_RECS_IN_RNG));
+        if (!this.IsVirtual &&
+            (task.getMode() === Constants.TASK_MODE_QUERY &&
+                !Environment.Instance.allowUpdateInQueryMode(task.getCompIdx())
+                || rec.InForceUpdate && rec.InCompute))
+            return !valsEqual;
+        if (checkForVariableChange && this.getHasChangeEvent()) {
+            let argsList = new Array(2);
+            argsList[0] = new ExpVal(StorageAttribute.NUMERIC, false, (mainCtrl !== null && mainCtrl.IsInteractiveUpdate
+                ? Field.NUM0.toXMLrecord()
+                : Field.NUM1.toXMLrecord()));
+            argsList[1] = new ExpVal(this.getType(), this.isNull(), this.getValue(false));
+            args = new ArgumentsList(argsList);
+        }
+        if (mainCtrl != null)
+            mainCtrl.IsInteractiveUpdate = false;
+        if (this._type !== StorageAttribute.UNICODE && UtilStrByteMode.isLocaleDefLangDBCS()) {
+            if (newVal != null)
+                remainder = this._size - UtilStrByteMode.lenB(newVal);
+            else
+                remainder = 0;
+            if (newVal != null && this._type !== StorageAttribute.BLOB && this._type !== StorageAttribute.BLOB_VECTOR &&
+                remainder < 0)
+                this._val = UtilStrByteMode.leftB(newVal, this._size);
+            else if (this._type === StorageAttribute.ALPHA && remainder > 0)
+                this._val = newVal + NString.FromChars(this._spaces, 0, remainder);
+            else if (this._type === StorageAttribute.BLOB)
+                this._val = BlobType.copyBlob(this._val, newVal);
+            else
+                this._val = newVal;
+        }
+        else {
+            if (newVal != null)
+                remainder = this._size - newVal.length;
+            else
+                remainder = 0;
+            if (newVal != null && this._type !== StorageAttribute.BLOB && this._type !== StorageAttribute.BLOB_VECTOR && remainder < 0)
+                this._val = newVal.substr(0, this._size);
+            else if ((this._type === StorageAttribute.ALPHA || this._type === StorageAttribute.UNICODE) && remainder > 0)
+                this._val = newVal + NString.FromChars(this._spaces, 0, remainder);
+            else if (this._type === StorageAttribute.BLOB) {
+                if (this._val === null)
+                    this._val = this.getMagicDefaultValue();
+                this._val = BlobType.copyBlob(this._val, newVal);
+            }
+            else
+                this._val = newVal;
+        }
+        {
+            recFldVal = rec.GetFieldValue(this._id);
+            let oldNullVal = this._isNull;
+            if (!recompute && !isArgUpdate && this._initExp == null)
+                oldNullVal = rec.IsNull(this._id);
+            try {
+                valsEqual = ExpressionEvaluator.mgValsEqual(this._val, isNullFld, this._type, recFldVal, oldNullVal, this._type);
+            }
+            catch (exception) {
+                this._val = this.getMagicDefaultValue();
+                valsEqual = false;
+            }
+        }
+        if (this._clearVectorType)
+            this._vectorType = null;
+        if (this._invalidValue) {
+            this._invalidValue = false;
+            rec.clearFlag(this._id, Record.FLAG_UPDATED);
+            rec.clearFlag(this._id, Record.FLAG_MODIFIED);
+        }
+        zeroReal = this._linkCreate && rec.InCompute && !recompute && (this._form == null || !this._form.InRestore) &&
+            !AccessHelper.eventsManager.GetStopExecutionFlag();
+        if ((this._isVirtual || zeroReal) && !rec.isNewRec() && !valsEqual)
+            forceUpdate = true;
+        if (checkForVariableChange || forceUpdate || rec.isNewRec()) {
+            this.UpdateNull(isNullFld, rec);
+            if (setCrsrModified)
+                rec.setFlag(this._id, Record.FLAG_CRSR_MODIFIED);
+            rec.setFieldValue(this._id, this._val, setRecordModified);
+            evts = Field._variableChangeEvts;
+            pendingEvents = evts.length;
+            if (checkForVariableChange && this.getHasChangeEvent() && !evts.Contains(this) && !valsEqual) {
+                let rtEvt = new RunTimeEvent(this);
+                rtEvt.setInternal(InternalInterface.MG_ACT_VARIABLE);
+                rtEvt.setArgList(args);
+                evts.push(this);
+                evts.push(rtEvt);
+            }
+            if (this._recompute != null && (recompute || forceUpdate) && !this._dataview.InLocalDataviewCommand) {
+                try {
+                    if (forceUpdate)
+                        rec.InForceUpdate = true;
+                    await this._recompute.execute(rec);
+                }
+                finally {
+                    if (forceUpdate)
+                        rec.InForceUpdate = false;
+                }
+            }
+            if (this._causeTableInvalidation && this.isChanged(this._val, isNullFld))
+                rec.setCauseInvalidation(true);
+            if ((recompute || forceUpdate) && !this._dataview.InLocalDataviewCommand && mainCtrl != null) {
+                if (mainCtrl.isChoiceControl())
+                    await this.updateDisplay();
+            }
+            if (pendingEvents === 0 && checkForVariableChange && this.getHasChangeEvent()) {
+                while (evts.length > 0) {
+                    let evt = evts.get_Item(1);
+                    evts.RemoveAt(0);
+                    evts.RemoveAt(0);
+                    if (LastFocusedManager.Instance.getLastFocusedTask() == null)
+                        evt.setTask(this.getTask());
+                    else {
+                        let taskRef = LastFocusedManager.Instance.getLastFocusedTask();
+                        if (taskRef.TaskSuffixExecuted) {
+                            taskRef = (taskRef.PathParentTask != null) ? taskRef.PathParentTask : taskRef;
+                        }
+                        evt.setTask(taskRef);
+                    }
+                    evt.setCtrl(LastFocusedManager.getLastFocusedControl());
+                    await AccessHelper.eventsManager.handleEvent(evt, false);
+                }
+            }
+        }
+        if (recompute && !valsEqual)
+            this.setModified();
+        return !valsEqual;
+    }
+    UpdateNull(isNullFld, rec) {
+        if (isNullFld)
+            rec.setFlag(this._id, Record.FLAG_NULL);
+        else
+            rec.clearFlag(this._id, Record.FLAG_NULL);
+        this._isNull = isNullFld;
+    }
+    async setCellVecValue(idx, newVal, valIsNull) {
+        let res = false;
+        if (this._type === StorageAttribute.BLOB_VECTOR) {
+            if (this._vectorType == null) {
+                this._vectorType = this.isNull()
+                    ? new VectorType(this._vecCellsType, this._vecCellsContentType, this.DefaultValue, this.isNullDefault(), this.NullAllowed, this._vecCellsSize)
+                    : new VectorType(this._val);
+            }
+            if (this._vecCellsType === StorageAttribute.BLOB) {
+                let tmpNewVal = this.getCellDefualtValue();
+                newVal = BlobType.copyBlob(tmpNewVal, newVal);
+            }
+            res = this._vectorType.setVecCell(idx, newVal, valIsNull);
+            if (res) {
+                this._clearVectorType = false;
+                await this.setValueAndStartRecompute(this._vectorType.toString(), false, true, false, false);
+                this._clearVectorType = true;
+            }
+        }
+        return res;
+    }
+    getVecCellValue(idx) {
+        if (this._type === StorageAttribute.BLOB_VECTOR) {
+            if (this._vectorType == null)
+                this._vectorType = new VectorType(this._val);
+            return this._vectorType.getVecCell(idx);
+        }
+        return null;
+    }
+    setRecomputed() {
+    }
+    invalidate(forceInvalidate, clearFlags) {
+        let rec = this._dataview.getCurrRec();
+        if (!this._isVirtual || this._virAsReal || this._initExp !== null || forceInvalidate) {
+            this._invalidValue = true;
+        }
+        if (clearFlags && rec !== null) {
+            rec.clearFlag(this._id, Record.FLAG_UPDATED);
+            rec.clearFlag(this._id, Record.FLAG_MODIFIED);
+        }
+    }
+    getTableName() {
+        if (this._tableName == null)
+            return "";
+        return this._tableName;
+    }
+    getName() {
+        if (this._isParam)
+            return "Parameter." + this.getVarName();
+        else if (this._isVirtual)
+            return "Virtual." + this.getVarName();
+        else
+            return this.getTableName() + "." + this.getVarName();
+    }
+    isNull() {
+        if (super.getTask().getEvalOldValues())
+            return this.isOriginalValueNull();
+        else if (this._invalidValue)
+            this.takeValFromRec();
+        return this._isNull;
+    }
+    PrevIsNull() {
+        return this._prevIsNull;
+    }
+    isModified() {
+        let currRec = this._dataview.getCurrRec();
+        return currRec.isFldModified(this._id);
+    }
+    setModified() {
+        let rec = (this._dataview.getCurrRec());
+        rec.setFlag(this._id, Record.FLAG_MODIFIED);
+        rec.setFlag(this._id, Record.FLAG_MODIFIED_ATLEAST_ONCE);
+        if (this.IsVirtual)
+            this.modifiedAtLeastOnce = true;
+    }
+    setUpdated() {
+        let currRec = this._dataview.getCurrRec();
+        currRec.setFlag(this._id, Record.FLAG_UPDATED);
+        currRec.setUpdated();
+    }
+    isParam() {
+        return this._isParam;
+    }
+    isInEvalProcess() {
+        return this._inEvalProcess;
+    }
+    hasInitExp() {
+        return this._initExp !== null;
+    }
+    isServerRcmp() {
+        return this._recompute !== null && this._recompute.isServerRcmp();
+    }
+    getPicture() {
+        return this._picture;
+    }
+    getDataviewHeaderId() {
+        return this._dataviewHeaderId;
+    }
+    get IsLinkField() {
+        return this._isLinkFld;
+    }
+    async getInitExpVal(res, isNull) {
+        if (this._initExp != null)
+            await this.EvaluateInitExpression(res, isNull);
+        else
+            res.value = this.getDefaultValue();
+    }
+    setHasChangeEvent() {
+        this._hasChangeEvent = true;
+    }
+    getHasChangeEvent() {
+        return this._hasChangeEvent;
+    }
+    setHasZoomHandler() {
+        this._hasZoomHandler = true;
+    }
+    getHasZoomHandler() {
+        return this._hasZoomHandler;
+    }
+    isCauseTableInvalidation() {
+        return this._causeTableInvalidation;
+    }
+    causeTableInvalidation(causeTableInvalidation) {
+        this._causeTableInvalidation = causeTableInvalidation;
+    }
+    getValueForNull(checkNullArithmetic) {
+        let val;
+        if (this.NullAllowed) {
+            if (checkNullArithmetic && super.getTask().getNullArithmetic() === Constants.NULL_ARITH_NULLIFY) {
+                val = null;
+            }
+            else {
+                if (this._nullValue === null) {
+                    this._nullValue = super.getMagicDefaultValue();
+                }
+                val = this._nullValue;
+            }
+        }
+        else {
+            val = super.getMagicDefaultValue();
+        }
+        return val;
+    }
+    getCtrl() {
+        let ctrl;
+        if (this._controls != null) {
+            for (let i = 0; i < this._controls.length; i++) {
+                ctrl = this._controls.get_Item(i);
+                if (ctrl.getForm().getTask() === this.getTask())
+                    return ctrl;
+            }
+        }
+        return null;
+    }
+    async updateDisplay() {
+        await super.updateDisplayWithValue(this.getDispValue(), this.isNull());
+    }
+    getDispValue() {
+        if (this.isNull()) {
+            if (this._nullDisplay != null)
+                return this.getNullDisplay();
+            else
+                return super.getMagicDefaultValue();
+        }
+        else
+            return this.getValue(false);
+    }
+    get ShouldCheckRangeInCompute() {
+        return this.IsLinkField || (this.IsVirtual && this._dataview.HasMainTable);
+    }
+    IsForArgument(taskHasParameters) {
+        if (taskHasParameters) {
+            if (!this.isParam()) {
+                return false;
+            }
+        }
+        else {
+            if (!this.IsVirtual) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Field.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/data/Field.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationException, Debug, List, NNumber, NString, RefParam, isNullOrUndefined} from \"@magic-xpa/mscorelib\";\r\nimport {\r\n  Constants,\r\n  InternalInterface,\r\n  Logger,\r\n  MsgInterface,\r\n  PICInterface,\r\n  StorageAttribute,\r\n  StrUtil,\r\n  UtilStrByteMode,\r\n  XMLConstants,\r\n  XmlParser\r\n} from \"@magic-xpa/utils\";\r\nimport {\r\n  BlobType,\r\n  DisplayConvertor,\r\n  ExpVal,\r\n  FieldDef,\r\n  MgControlBase,\r\n  NUM_TYPE,\r\n  PIC,\r\n  VectorType\r\n} from \"@magic-xpa/gui\";\r\n\r\nimport {YesNoExp} from \"../exp/YesNoExp\";\r\nimport {Expression} from \"../exp/Expression\";\r\nimport {ExpressionEvaluator} from \"../exp/ExpressionEvaluator\";\r\nimport {MgForm} from \"../gui/MgForm\";\r\nimport {MgControl} from \"../gui/MgControl\";\r\nimport {Recompute, Recompute_RcmpBy} from \"../rt/Recompute\";\r\nimport {Boundary} from \"../rt/Boundary\";\r\nimport {ArgumentsList} from \"../rt/ArgumentsList\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {RunTimeEvent} from \"../event/RunTimeEvent\";\r\nimport {Record} from \"./Record\";\r\nimport {DataView} from \"./DataView\";\r\nimport { Environment } from \"../env/Environment\";\r\nimport { FieldBase } from \"./FieldBase\";\r\nimport { LastFocusedManager } from \"../rt/LastFocusedManager\";\r\nimport { LanguageData } from \"../env/LanguageData\";\r\nimport { AccessHelper } from \"../AccessHelper\";\r\n\r\n/// <summary>\r\n///   data for <fldh ...>\r\n/// </summary>\r\nexport class Field extends FieldBase {\r\n  static LEAVE_FLAGS: boolean = false;\r\n\r\n  private static NUM0: NUM_TYPE = null;\r\n  private static NUM1: NUM_TYPE = null;\r\n\r\n  private _linkExp: YesNoExp = null;\r\n  private _recompute: Recompute = null;\r\n  CacheTableFldIdx: number = 0;\r\n  private _causeTableInvalidation: boolean = false; // change in this field will cause invalidation of all rows in table\r\n  private _form: MgForm = null;\r\n  private _hasChangeEvent: boolean = false; // if TRUE, there is a handler to run when this field is updated\r\n  private _hasZoomHandler: boolean = false; // if TRUE, there is a zoom handler for this field\r\n  private _inEvalProcess: boolean = false;\r\n  private _initExp: Expression = null;\r\n  private _invalidValue: boolean = true;\r\n  private _isLinkFld: boolean = false; // if TRUE, it means that the field belongs to a link\r\n  private _isVirtual: boolean = false;\r\n  private _dataviewHeaderId: number = -1;  // members related to table cache\r\n  private _linkCreate: boolean = false; // If true then it's a real field which belongs to link create.\r\n  Locate: Boundary = null;\r\n  Range: Boundary = null;\r\n  private _isParam: boolean = false;\r\n  private _isExposedRouteParam: boolean = false;\r\n  private _isExposedToClient: boolean = true;\r\n  private _prevIsNull: boolean = false;\r\n  private _prevValue: string = null;\r\n  private _tableName: string = null;\r\n  private _indexInTable: number = -1;\r\n\r\n  private _virAsReal: boolean = false; // If true then a virtual field is computed as real (needed for link ret value)\r\n  protected _val: string = null;\r\n  private modifiedAtLeastOnce: boolean = false;\r\n  private _isNull: boolean = false;\r\n  private _clearVectorType: boolean = true; // do we need to update the vector object\r\n  private _vectorType: VectorType = null; // the vector representation\r\n\r\n  private static _variableChangeEvts: List<Field | RunTimeEvent> = new List(); // for Variable Change event execution, previously used via getPendingVarChangeEvents\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  /// <param name = \"dataview\">a reference to the dataview</param>\r\n  /// <param name = \"id\">counter of the field in FieldTable</param>\r\n  constructor(dataview: DataView, id: number) {\r\n    super(id);\r\n    if (Field.NUM0 === null) {\r\n      Field.NUM0 = new NUM_TYPE();\r\n      Field.NUM1 = new NUM_TYPE();\r\n      Field.NUM0.NUM_4_LONG(0);\r\n      Field.NUM1.NUM_4_LONG(1);\r\n    }\r\n\r\n    this._dataview = dataview;\r\n    this._linkExp = new YesNoExp(false);\r\n    FieldDef._default_date = DisplayConvertor.Instance.disp2mg(PICInterface.DEFAULT_DATE,\r\n      new PIC(\"6\", StorageAttribute.NUMERIC, super.getTask().getCompIdx()),\r\n      super.getTask().getCompIdx(),\r\n      BlobType.CONTENT_TYPE_UNKNOWN);\r\n  }\r\n\r\n\r\n  get VirAsReal(): boolean {\r\n    return this._virAsReal;\r\n  }\r\n\r\n  get IsVirtual(): boolean {\r\n    return this._isVirtual;\r\n  }\r\n\r\n  get IsExposedRouteParam(): boolean {\r\n    return this._isExposedRouteParam;\r\n  }\r\n\r\n  get IsExposedToClient(): boolean {\r\n    return this._isExposedToClient;\r\n  }\r\n\r\n  /// <summary>\r\n  /// index in table\r\n  /// </summary>\r\n  get IndexInTable(): number {\r\n    return this._indexInTable;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the field attribute\r\n  /// </summary>\r\n  protected setAttribute(attribute: string, valueStr: string): boolean {\r\n    let isTagProcessed: boolean = super.setAttribute(attribute, valueStr);\r\n    if (!isTagProcessed) {\r\n      let data: string[] = StrUtil.tokenize(valueStr, \",\");\r\n      isTagProcessed = true;\r\n      switch (attribute) {\r\n        case ConstInterface.MG_ATTR_VIRTUAL:\r\n          this._isVirtual = (XmlParser.getInt(valueStr) !== 0);\r\n          break;\r\n        case ConstInterface.MG_ATTR_PARAM:\r\n          this._isParam = (XmlParser.getInt(valueStr) !== 0);\r\n          if (!this._isVirtual && this._isParam)\r\n          // possible error - we rely on the order of XML attributes\r\n            throw new ApplicationException(\r\n              \"in Field.initElements(): non virtual field is defined as a parameter\");\r\n          break;\r\n        case ConstInterface.MG_ATTR_EXPOSED_ROUTE_PARAMS:\r\n          this._isExposedRouteParam = (XmlParser.getInt(valueStr) !== 0);\r\n          if (!this._isParam && this._isExposedRouteParam)\r\n          // possible error - we rely on the order of XML attributes\r\n            throw new ApplicationException(\r\n              \"in Field.initElements(): non parameter field is defined as a exposed route parameter\");\r\n          break;\r\n        case ConstInterface.MG_ATTR_EXPOSED_TO_CLIENT:\r\n          // The flag was serialized only for server variable (expose to client = 0 )\r\n          if (XmlParser.getInt(valueStr) == 0)\r\n            this._isExposedToClient = false;\r\n          break;\r\n        case ConstInterface.MG_ATTR_VIR_AS_REAL:\r\n          this._virAsReal = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_LNK_CREATE:\r\n          this._linkCreate = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_LNKEXP:\r\n          this._linkExp.setVal(<Task>(this.getTask()), valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_TABLE_NAME:\r\n          this._tableName = XmlParser.unescape(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_INDEX_IN_TABLE:\r\n          this._indexInTable = XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_INIT:\r\n          let expNum: number = XmlParser.getInt(valueStr);\r\n          this._initExp = (<Task>this.getTask()).getExpById(expNum);\r\n          break;\r\n        case XMLConstants.MG_ATTR_NAME: {\r\n\r\n        }\r\n          break;\r\n        case ConstInterface.MG_ATTR_CHACHED_FLD_ID:\r\n          // MG_ATTR_CHACHED_FLD is in the format of cachedTableId,fld\r\n          if (data[0] != \"\")\r\n            this.CacheTableFldIdx = NNumber.Parse(data[1]);\r\n          break;\r\n        case ConstInterface.MG_ATTR_LOCATE:\r\n          // locate is in the format of max,min expression num (-1 if non exists)\r\n          this.Locate = new Boundary(<Task>this.getTask(), NNumber.Parse(data[1]), NNumber.Parse(data[0]), this.getType(), this.getSize(), this.CacheTableFldIdx);\r\n          break;\r\n        case ConstInterface.MG_ATTR_RANGE:\r\n          // range is in the format of max,min expression num (-1 if non exists)\r\n          this.Range = new Boundary(<Task>this.getTask(), NNumber.Parse(data[1]), NNumber.Parse(data[0]), this.getType(), this.getSize(), this.CacheTableFldIdx);\r\n          break;\r\n        case ConstInterface.MG_ATTR_LINK:\r\n          this._dataviewHeaderId = NNumber.Parse(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_IS_LINK_FIELD:\r\n          this._isLinkFld = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        default:\r\n          isTagProcessed = false;\r\n          Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unrecognized attribute: '{0}'\", attribute));\r\n          break;\r\n      }\r\n    }\r\n    return isTagProcessed;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set a reference to the Recompute Object of this field\r\n  /// </summary>\r\n  /// <param name = \"recompRef\">reference to Recompute Object</param>\r\n  setRecompute(recompRef: Recompute): void {\r\n    this._recompute = recompRef;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Removes the specific subform task from the recompute\r\n  /// </summary>\r\n  /// <param name=\"subformTask\"></param>\r\n  RemoveSubformFromRecompute(subformTask: Task): void {\r\n    if (this._recompute !== null) {\r\n      this._recompute.RemoveSubform(subformTask);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Insert the specific subform task into the field recompute\r\n  /// </summary>\r\n  /// <param name=\"subformTask\"></param>\r\n  AddSubformRecompute(subformTask: Task): void {\r\n    if (this._recompute === null) {\r\n      this._recompute = new Recompute();\r\n      this._recompute.Task = <Task>super.getTask();\r\n      this._recompute.OwnerFld = this;\r\n      this._recompute.RcmpMode = Recompute_RcmpBy.CLIENT;\r\n    }\r\n    this._recompute.AddSubform(subformTask);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   set a reference to a control attached to this field\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">the control which is attached to this field</param>\r\n  SetControl(ctrl: MgControlBase): void {\r\n    super.SetControl(ctrl);\r\n\r\n    if (this._isVirtual && ctrl.IsRepeatable && this._initExp === null) {\r\n      this._causeTableInvalidation = true;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   compute the field init expression or get its value from the dataview, set\r\n  ///   the value of the field (and update the display)\r\n  /// </summary>\r\n  /// <param name = \"recompute\">tells the compute to start the recompute chain and recompute\r\n  ///   the expression of this field (if it is real)\r\n  /// </param>\r\n  public async compute(recompute: boolean): Promise<void> {\r\n    let result: RefParam<string> = new RefParam(this.getValue(false));\r\n    let isNullFld: RefParam<boolean> = new RefParam(this._isNull);\r\n    let rec = (<DataView>this._dataview).getCurrRec();\r\n    let task = <Task>super.getTask();\r\n\r\n    let zeroReal: boolean = this._linkCreate && rec.InCompute && !recompute && task.getMode() === Constants.TASK_MODE_CREATE;\r\n    // QCR #999024 - zero lnk create values during compute\r\n\r\n    if (this._form == null)\r\n      this._form = <MgForm>task.getForm();\r\n\r\n    // no need to zero reals if we are recovering a record.\r\n    if ((this._form != null && this._form.InRestore) || AccessHelper.eventsManager.GetStopExecutionFlag())\r\n      zeroReal = false;\r\n\r\n    let rtEvt: RunTimeEvent = AccessHelper.eventsManager.getLastRtEvent();\r\n    let computeOnCancelEvent: boolean = false;\r\n    if (rtEvt != null)\r\n      computeOnCancelEvent = rtEvt.getInternalCode() === InternalInterface.MG_ACT_CANCEL;\r\n\r\n    // virtual as real is especially for fields which are used as a \"return value\"\r\n    // of a link. Their value is returned by the link result and not by the init expression.\r\n    // when the form is restoring the curr row we shouldn't compute the init expression\r\n    // but to use the value from the record (by getValue)\r\n    // QCR#926758: When Task's mode is Create, init for real field should be evaluated only when it comes for cancel event(last runtime event is cancel event).\r\n    // While creating a new record, init will be evaluated because of condition rec.isNewRec(). (It is the refix of QCR#994072)\r\n    if (!this._virAsReal && (this._form == null || !this._form.InRestore) &&\r\n      ((this._isVirtual || (task.getMode() === Constants.TASK_MODE_CREATE && computeOnCancelEvent)) || recompute ||\r\n        zeroReal || rec.isNewRec() && !rec.isComputed())) {\r\n      if (!task.DataView.isEmptyDataview() || (task.DataView.isEmptyDataview() && !this.PartOfDataview)) {\r\n        // QCR #775508: for dataviews, which are computed by the server, prevent\r\n        // computing the init expression while in compute of the record because the\r\n        // server have already done it\r\n        if ((this._isVirtual || task.getMode() === Constants.TASK_MODE_CREATE) || (<DataView>this._dataview).computeByClient() ||\r\n          !rec.InCompute || zeroReal || rec.lateCompute()) {\r\n          if (this._initExp != null) {\r\n\r\n\r\n            await this.EvaluateInitExpression(result, isNullFld);\r\n          }\r\n          else if (zeroReal)\r\n            result.value = this.getDefaultValue();\r\n        }\r\n      }\r\n    }\r\n    if (this._invalidValue) {\r\n      this._prevValue = result.value;\r\n      this._prevIsNull = isNullFld.value;\r\n    }\r\n    await this.setValue(result.value, isNullFld.value, recompute, false, recompute && !this._isVirtual, false, false);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// evaluate init expression\r\n  /// </summary>\r\n  /// <param name=\"result\"></param>\r\n  /// <param name=\"isNullFld\"></param>\r\n  async EvaluateInitExpression(result: RefParam<string>, isNullFld: RefParam<boolean>): Promise<void> {\r\n    Debug.Assert(this._initExp !== null);\r\n    try {\r\n      this._inEvalProcess = true;\r\n      result.value = await this._initExp.evaluateWithResultTypeAndLength(this._type, this._size);\r\n    }\r\n    finally {\r\n      this._inEvalProcess = false;\r\n    }\r\n\r\n    isNullFld.value = (result.value === null);\r\n    if (isNullFld.value && this.NullAllowed) {\r\n      result.value = this.getValue(false);\r\n    }\r\n  }\r\n\r\n  ///// <summary>\r\n  /////\r\n  ///// </summary>\r\n  ///// <param name=\"recompute\"></param>\r\n  ///// <returns></returns>\r\n  // bool ShouldRecompute(bool recompute)\r\n  // {\r\n  //   if (recompute)\r\n  //   {\r\n  //      bool computedByFetch = !IsVirtual || VirAsReal;\r\n  //      if (computedByFetch)\r\n  //      {\r\n  //         Task task = (Task)getTask();\r\n  //         DataviewHeaderBase header = task.getDataviewHeaders().getDataviewHeaderById(_dataviewHeaderId);\r\n  //         //local datavase already computed the record as server does\r\n  //         if (header is LocalDataviewHeader)\r\n  //         {\r\n  //             var rec = ((DataView)_dataview).getCurrRec();\r\n  //             return !rec.InCompute;\r\n  //         }\r\n  //      }\r\n  //   }\r\n  //   return recompute;\r\n  // }\r\n\r\n  /// <summary>\r\n  ///   get the value of the field from the current record\r\n  /// </summary>\r\n  /// <param name = \"checkNullArithmetic\">if true then the null arithmetic environment\r\n  ///   setting is used to return null when \"nullify\" computation is needed\r\n  /// </param>\r\n  getValue(checkNullArithmetic: boolean): string {\r\n    // if we need to return the original value of the field\r\n    if ((<Task>super.getTask()).getEvalOldValues())\r\n      return this.getOriginalValue();\r\n    if (this._invalidValue)\r\n      this.takeValFromRec();\r\n    if (this._isNull)\r\n      this._val = this.getValueForNull(checkNullArithmetic);\r\n    return this._val;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"newValue\"></param>\r\n  /// <param name = \"isNull\"></param>\r\n  /// <returns></returns>\r\n  private isChanged(newValue: string, isNull: boolean): boolean {\r\n    return this._prevValue !== null && (!(this._prevValue === newValue) || this._prevIsNull !== isNull);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the field by taking it from the current record\r\n  /// </summary>\r\n  takeValFromRec(): void {\r\n    let rec: Record = (<DataView>this._dataview).getCurrRec();\r\n    if (rec !== null) {\r\n      this._val = rec.GetFieldValue(this._id);\r\n      this._isNull = rec.IsNull(this._id);\r\n    }\r\n    if (this._invalidValue) {\r\n      if (rec !== null && this._causeTableInvalidation && this.isChanged(this._val, this._isNull) && this._form !== null) {\r\n        rec.setCauseInvalidation(true);\r\n      }\r\n      this._prevValue = this._val;\r\n      this._prevIsNull = this._isNull;\r\n      this._invalidValue = false;\r\n    }\r\n    // ZERO THE VECTOR OBJECT\r\n    this._vectorType = null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the original value of the field without updating the field value\r\n  /// </summary>\r\n  getOriginalValue(): string {\r\n    let originalRec: Record = (<DataView>this._dataview).getOriginalRec();\r\n\r\n    if (originalRec.IsNull(this._id))\r\n      return this.getMagicDefaultValue();\r\n\r\n    return originalRec.GetFieldValue(this._id);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   is original value of the field was null\r\n  /// </summary>\r\n  isOriginalValueNull(): boolean {\r\n    let originalRec: Record = (<DataView>this._dataview).getOriginalRec();\r\n    return originalRec.IsNull(this._id);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get value by rec idx\r\n  /// </summary>\r\n  /// <param name = \"idx\">record idx</param>\r\n  /// <returns></returns>\r\n  getValueByRecIdx(idx: number): string {\r\n    let rec: Record = (<DataView>this._dataview).getRecByIdx(idx);\r\n    let fieldValue: string = rec.GetFieldValue(this._id);\r\n    return rec.IsNull(this._id) ? this.getValueForNull(false) : fieldValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get modifiedAtLeastOnce flag\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getModifiedAtLeastOnce(): boolean {\r\n    return this.modifiedAtLeastOnce;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return null if value of field for the record is null\r\n  /// </summary>\r\n  /// <param name = \"idx\">record idx</param>\r\n  /// <returns></returns>\r\n  isNullByRecIdx(idx: number): boolean {\r\n    let rec: Record = (<DataView>this._dataview).getRecByIdx(idx);\r\n    return rec.IsNull(this._id);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if field's value for record idx recidx equals to mgValue\r\n  /// </summary>\r\n  /// <param name=\"mgValue\">value to compare  </param>\r\n  /// <param name=\"isNullFld\"></param>\r\n  /// <param name=\"type\">type of value</param>\r\n  /// <param name=\"recIdx\">recIdx of the record</param>\r\n  /// <returns></returns>\r\n  isEqual(mgValue: string, isNullFld: boolean, type: StorageAttribute, recIdx: number): boolean {\r\n    let rec = <Record>((<DataView>this._dataview).getRecByIdx(recIdx));\r\n    let valsEqual: boolean = false;\r\n    if (rec != null) {\r\n      let fieldValue: string = rec.GetFieldValue(this._id);\r\n      let fielsIsNull: boolean = rec.IsNull(this._id);\r\n      valsEqual = ExpressionEvaluator.mgValsEqual(fieldValue, fielsIsNull, this._type, mgValue, isNullFld, type);\r\n    }\r\n    return valsEqual;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value of this field which should be inserted into a new rec, when it\r\n  ///   is created. This will usually be the field's default value, unless there is a\r\n  ///   virtual field without an init expression. In this case, the current value will be\r\n  ///   returned.\r\n  /// </summary>\r\n  /// <param name=\"clobberedOnly\">clobberedOnly is true if we want to only take the values of the virtuals with no init expression</param>\r\n  getNewRecValue(clobberedOnly: boolean): string {\r\n    if (this._isVirtual && this._initExp == null)\r\n      return this._val;\r\n    return !clobberedOnly ? this.getDefaultValue() : null;\r\n  }\r\n\r\n  async setValueAndStartRecompute(val: string, isNullFld: boolean, recompute: boolean, setRecordUpdated: boolean, isArgUpdate: boolean, enforceVariableChange?: boolean): Promise<void> {\r\n    if (isNullOrUndefined(enforceVariableChange))\r\n      enforceVariableChange = false;\r\n    await this.setValueAndStartRecompute_1(val, isNullFld, recompute, setRecordUpdated, isArgUpdate, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   call the set value function from the \"outer\" world. This will trigger the recompute\r\n  ///   chain. When recompute is done - refresh controls which are expression dependent.\r\n  /// </summary>\r\n  /// <param name=\"val\">the new value of the field</param>\r\n  /// <param name=\"isNullFld\">if true then the value is null</param>\r\n  /// <param name=\"recompute\">states whether to execute recompute when setting the value</param>\r\n  /// <param name=\"recomputeOnlyWhenUpdateValue\">: do the recompute only when the value was update</param>\r\n  /// <param name=\"setRecordUpdated\">tells whether to define the record as updated</param>\r\n  /// <param name=\"isArgUpdate\">true if called for handler argument-parameter copy</param>\r\n  /// <param name=\"enforceVariableChange\">execute vaiable change even when recompute is false</param>\r\n  private async setValueAndStartRecompute_1(val: string, isNullFld: boolean, recompute: boolean, setRecordUpdated: boolean, isArgUpdate: boolean, enforceVariableChange: boolean): Promise<void> {\r\n    let task = <Task>this.getTask();\r\n    if (task != null)\r\n      task.VewFirst++;\r\n\r\n    let valueWasUpdated: boolean = await this.setValue(val, isNullFld, recompute, setRecordUpdated, !this._isVirtual, isArgUpdate, enforceVariableChange);\r\n\r\n    // A field that is an event handler field cannot appear as a property in gui. no need to refresh all\r\n    // form+controls properties expressions for it.\r\n    if (task !== null && task.VewFirst === 1 && this._form !== null && !this.IsEventHandlerField) {\r\n      if (recompute && valueWasUpdated)\r\n        await this._form.refreshOnExpressions();\r\n\r\n    }\r\n    if (task != null)\r\n      task.VewFirst--;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the field in the current record and update the display\r\n  ///   the field must be in a magic internal format\r\n  /// </summary>\r\n  /// <param name=\"newVal\">the new value of the field</param>\r\n  /// <param name=\"isNullFld\">if true then the value is null</param>\r\n  /// <param name=\"recompute\">states whether to execute recompute when setting the value</param>\r\n  /// <param name=\"setRecordModified\">states whether to define the record as modified</param>\r\n  /// <param name=\"setCrsrModified\">states whether to define the cursor of the field as modified</param>\r\n  /// <param name=\"isArgUpdate\">true if called for handler argument-parameter copy</param>\r\n  /// <returns>the return value was updated </returns>\r\n  private async setValue(newVal: string, isNullFld: boolean, recompute: boolean, setRecordModified: boolean, setCrsrModified: boolean, isArgUpdate: boolean, enforceValiableChange: boolean): Promise<boolean> {\r\n    let rec: Record;\r\n    let recFldVal: string;\r\n    let valsEqual: boolean = false;\r\n    let remainder: number;\r\n    let zeroReal: boolean;\r\n    let args: ArgumentsList = null;\r\n    let mainCtrl = this.getCtrl();\r\n    let pendingEvents: number;\r\n    let evts: List<Field | RunTimeEvent>;\r\n    let forceUpdate: boolean = false;\r\n    let checkForVariableChange: boolean = recompute || enforceValiableChange;\r\n\r\n    let task = <Task>this.getTask();\r\n    if (this._form === null)\r\n      this._form = <MgForm>task.getForm();\r\n\r\n    if (isNullFld && !this.NullAllowed && this._type !== StorageAttribute.BLOB_VECTOR) {\r\n      newVal = this.getDefaultValue();\r\n      isNullFld = false;\r\n    }\r\n\r\n    // QCR#805364: For any field, we store the value in field as it is (without checking the picture).\r\n    // But for Numeric field, if picture does not contain decimals then we should round off the value and then save this value in field\r\n    // otherwise it will give wrong calculation. So always round off the value depending on picture's decimal.\r\n    // check if newVal is \"long\" since there is no reason to round an already whole number\r\n    if (this._type === StorageAttribute.NUMERIC && newVal != null && !NUM_TYPE.numHexStrIsLong(newVal)) {\r\n      let numVal = new NUM_TYPE(newVal);\r\n      let pic = new PIC(this._picture, this._type, super.getTask().getCompIdx());\r\n      let decs: number = pic.getDec();\r\n      numVal.round(decs);\r\n      newVal = numVal.toXMLrecord();\r\n    }\r\n\r\n    rec = (<DataView>this._dataview).getCurrRec();\r\n    if (rec == null)\r\n      throw new ApplicationException(LanguageData.Instance.getConstMessage(MsgInterface.RT_STR_NO_RECS_IN_RNG));\r\n\r\n    // don't allow updating REAL fields, unless 'allow update in query mode' is set to TRUE\r\n    if (!this.IsVirtual &&\r\n      (task.getMode() === Constants.TASK_MODE_QUERY &&\r\n        !Environment.Instance.allowUpdateInQueryMode(task.getCompIdx())\r\n        || rec.InForceUpdate && rec.InCompute))\r\n      return !valsEqual;\r\n\r\n    if (checkForVariableChange && this.getHasChangeEvent()) {\r\n      let argsList = new Array(2);\r\n      argsList[0] = new ExpVal(StorageAttribute.NUMERIC, false,\r\n        (mainCtrl !== null && mainCtrl.IsInteractiveUpdate\r\n          ? Field.NUM0.toXMLrecord()\r\n          : Field.NUM1.toXMLrecord()));\r\n      argsList[1] = new ExpVal(this.getType(), this.isNull(), this.getValue(false));\r\n      args = new ArgumentsList(argsList);\r\n    }\r\n    if (mainCtrl != null)\r\n      mainCtrl.IsInteractiveUpdate = false;\r\n\r\n    // update the field in the current record\r\n    if (this._type !== StorageAttribute.UNICODE && UtilStrByteMode.isLocaleDefLangDBCS()) {\r\n      // count the number of bytes, not characters (JPN: DBCS support)\r\n      if (newVal != null)\r\n        remainder = this._size - UtilStrByteMode.lenB(newVal);\r\n      else\r\n        remainder = 0;\r\n\r\n      if (newVal != null && this._type !== StorageAttribute.BLOB && this._type !== StorageAttribute.BLOB_VECTOR &&\r\n        remainder < 0)\r\n        this._val = UtilStrByteMode.leftB(newVal, this._size);\r\n      else if (this._type === StorageAttribute.ALPHA && remainder > 0)\r\n        this._val = newVal + NString.FromChars(this._spaces, 0 , remainder);\r\n      else if (this._type === StorageAttribute.BLOB)\r\n        this._val = BlobType.copyBlob(this._val, newVal);\r\n      else this._val = newVal;\r\n    }\r\n    else {\r\n      if (newVal != null)\r\n        remainder = this._size - newVal.length;\r\n      else\r\n        remainder = 0;\r\n\r\n      if (newVal != null && this._type !== StorageAttribute.BLOB && this._type !== StorageAttribute.BLOB_VECTOR && remainder < 0)\r\n        this._val = newVal.substr(0, this._size);\r\n      else if ((this._type === StorageAttribute.ALPHA || this._type === StorageAttribute.UNICODE) && remainder > 0)\r\n        this._val = newVal +  NString.FromChars(this._spaces, 0 , remainder);\r\n      else if (this._type === StorageAttribute.BLOB) {\r\n        // Ensure _val is not null, so that the blob copy will be\r\n        // done correctly, according to the field's blob type.\r\n        if (this._val === null)\r\n          this._val = this.getMagicDefaultValue();\r\n        this._val = BlobType.copyBlob(this._val, newVal);\r\n      }\r\n      else this._val = newVal;\r\n    }\r\n    // If dotnet var is updated with new blobprefix, valsEqual is false, we should not check in record.\r\n    {\r\n      recFldVal = rec.GetFieldValue(this._id);\r\n\r\n      // In order to compare, If virtual's old value is taken from record, then old isNull value also should be taken from record.\r\n      // This should be done only if not in re-compute / not argument / no initExp.)\r\n      // Mainly , this is needed, when cursor is parked on one record and virtual is modified from null to nonnull or viceversa and\r\n      // now if cursor moves from one record to next record, We need to  get the old null value from record.\r\n\r\n      let oldNullVal: boolean = this._isNull;\r\n      if (!recompute && !isArgUpdate && this._initExp == null)\r\n        oldNullVal = rec.IsNull(this._id);\r\n\r\n      try {\r\n        valsEqual = ExpressionEvaluator.mgValsEqual(this._val, isNullFld, this._type, recFldVal, oldNullVal, this._type);\r\n      }\r\n      catch (exception) {\r\n        this._val = this.getMagicDefaultValue();\r\n        valsEqual = false;\r\n      }\r\n\r\n    }\r\n    // zero the vector\r\n    if (this._clearVectorType)\r\n      this._vectorType = null;\r\n    if (this._invalidValue) {\r\n      this._invalidValue = false;\r\n      rec.clearFlag(this._id, Record.FLAG_UPDATED);\r\n      rec.clearFlag(this._id, Record.FLAG_MODIFIED);\r\n    }\r\n    // during compute, we should zero fields which belong to link create.\r\n    zeroReal = this._linkCreate && rec.InCompute && !recompute && (this._form == null || !this._form.InRestore) &&\r\n      !AccessHelper.eventsManager.GetStopExecutionFlag();\r\n\r\n    // Virtuals without init expression are copied from one record to another, even at\r\n    // compute time (no recompute). Nevertheless, in case their value changes, we must\r\n    // perform recompute.\r\n    if ((this._isVirtual || zeroReal) && !rec.isNewRec() && !valsEqual)\r\n      forceUpdate = true;\r\n\r\n    // if the recompute is false it means that the user is setting a value\r\n    // that its source is the record, thus, we don't have to update the record.\r\n    // if the recompute is true, go ahead and update the record.\r\n    if (checkForVariableChange || forceUpdate || rec.isNewRec()) {\r\n      this.UpdateNull(isNullFld, rec);\r\n\r\n      if (setCrsrModified)\r\n        rec.setFlag(this._id, Record.FLAG_CRSR_MODIFIED);\r\n      rec.setFieldValue(this._id, this._val, setRecordModified);\r\n      evts = Field._variableChangeEvts;\r\n      pendingEvents = evts.length;\r\n      if (checkForVariableChange && this.getHasChangeEvent() && !evts.Contains(this) && !valsEqual) {\r\n        // if there is a variable change handler - save value and prepare params\r\n        let rtEvt = new RunTimeEvent(this);\r\n        rtEvt.setInternal(InternalInterface.MG_ACT_VARIABLE);\r\n        rtEvt.setArgList(args);\r\n        evts.push(this);\r\n        evts.push(rtEvt);\r\n      }\r\n\r\n      // check for recompute and execute it\r\n      // QCR #299609, if we are in local dataview manager, we can only compute.\r\n      // Recompute is not allowed, since it will be executed multiple times\r\n      if (this._recompute != null && (recompute || forceUpdate) && !(<DataView>this._dataview).InLocalDataviewCommand) {\r\n        try {\r\n          // if field caused table invalidation and it's value was changed\r\n          if (forceUpdate)\r\n            rec.InForceUpdate = true;\r\n          await this._recompute.execute(rec);\r\n        }\r\n\r\n        finally {\r\n          if (forceUpdate)\r\n            rec.InForceUpdate = false;\r\n        }\r\n      }\r\n      if (this._causeTableInvalidation && this.isChanged(this._val, isNullFld))\r\n        rec.setCauseInvalidation(true);\r\n\r\n      // Don't update controls while fetching records from local database. If the task has a table control, then actual controls on the\r\n      // rows are created after no. of rows is known (and this is after the data is avaialable). So, while fetching records, controls in\r\n      // table are not yet created and hence there is an assert while trying to update the controls. After skipping this update, the controls\r\n      // are updated from other places (refreshTable, commonHandlerBefore, handleRowDataCurPage etc like it happens for server data)\r\n      if ((recompute || forceUpdate) && !(<DataView>this._dataview).InLocalDataviewCommand && mainCtrl != null) {\r\n        if (mainCtrl.isChoiceControl())\r\n          await this.updateDisplay();\r\n      }\r\n\r\n      // Right after we exit the topmost update - execute all variable change events.\r\n      // note that during this execution, new ones may be created.\r\n      if (pendingEvents === 0 && checkForVariableChange && this.getHasChangeEvent()) {\r\n        while (evts.length > 0) {\r\n          let evt = <RunTimeEvent>evts.get_Item(1);\r\n          evts.RemoveAt(0);\r\n          evts.RemoveAt(0);\r\n          if (LastFocusedManager.Instance.getLastFocusedTask() == null)\r\n            evt.setTask(<Task>this.getTask());\r\n          else {\r\n            let taskRef: Task = LastFocusedManager.Instance.getLastFocusedTask();\r\n            // If we are in variable change event and TaskSuffix is executed, it means we are here from\r\n            // update arguments while closing the task. In such case, we should set the event task as PathParentTask\r\n            // and not the task itself.\r\n            if (taskRef.TaskSuffixExecuted) {\r\n              taskRef = (taskRef.PathParentTask != null) ? <Task>taskRef.PathParentTask : taskRef;\r\n            }\r\n            evt.setTask(taskRef);\r\n          }\r\n          evt.setCtrl(LastFocusedManager.getLastFocusedControl());\r\n          await AccessHelper.eventsManager.handleEvent(evt, false);\r\n        }\r\n      }\r\n    }\r\n    // #776031 - the field should be marked modified only if val are not equal. Otherwise, even for null field paramter passing\r\n    // or same value update, it is marked as modified and RS is executed.\r\n    if (recompute && !valsEqual)\r\n      this.setModified();\r\n    return !valsEqual;\r\n  }\r\n\r\n  UpdateNull(isNullFld: boolean, rec: Record): void {\r\n    if (isNullFld)\r\n      rec.setFlag(this._id, Record.FLAG_NULL);\r\n    else\r\n      rec.clearFlag(this._id, Record.FLAG_NULL);\r\n    this._isNull = isNullFld;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set a vec cell\r\n  ///   can not be executed without the logic from eval_op_vecGet\r\n  /// </summary>\r\n  /// <param name = \"idx\">the cell index in the vector strats from 1</param>\r\n  /// <param name = \"newVal\">the new value</param>\r\n  /// <param name = \"valIsNull\">is the bew value null</param>\r\n  async setCellVecValue(idx: number, newVal: string, valIsNull: boolean): Promise<boolean> {\r\n    let res: boolean = false;\r\n    if (this._type === StorageAttribute.BLOB_VECTOR) {\r\n      // initialized the vector object if needed\r\n      if (this._vectorType == null) {\r\n        this._vectorType = this.isNull()\r\n          ? new VectorType(this._vecCellsType, this._vecCellsContentType, this.DefaultValue, this.isNullDefault(),\r\n          this.NullAllowed, this._vecCellsSize)\r\n          : new VectorType(this._val);\r\n      }\r\n      // if vecCellsType is BLOB, convert data into blob\r\n      if (this._vecCellsType === StorageAttribute.BLOB) {\r\n        let tmpNewVal: string = this.getCellDefualtValue();\r\n        newVal = BlobType.copyBlob(tmpNewVal, newVal);\r\n      }\r\n\r\n      res = this._vectorType.setVecCell(idx, newVal, valIsNull);\r\n      // start recompute\r\n      if (res) {\r\n        this._clearVectorType = false;\r\n        // QCR 984563 do not set the record as changed\r\n        await this.setValueAndStartRecompute(this._vectorType.toString(), false, true, false, false);\r\n        this._clearVectorType = true;\r\n      }\r\n    }\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the cell value of a given cell in the vector\r\n  /// </summary>\r\n  /// <returns> the cell's value as string</returns>\r\n  getVecCellValue(idx: number): string {\r\n    if (this._type === StorageAttribute.BLOB_VECTOR) {\r\n      // if we are here than the filed must have none null value of a vector\r\n      if (this._vectorType == null)\r\n        this._vectorType = new VectorType(this._val);\r\n\r\n      return this._vectorType.getVecCell(idx);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the recomputed variable to true\r\n  /// </summary>\r\n  setRecomputed(): void {\r\n  }\r\n\r\n  /// <summary>\r\n  ///   invalidate the value of the field. An invalid value forces us to re-calculate the field's\r\n  ///   value by copying it from the dataview.\r\n  ///   used when switching to another record\r\n  /// </summary>\r\n  /// <param name = \"forceInvalidate\">- Dont check the field's type and make it invalid (usually Virtuals\r\n  ///   without init expression are never invalidated, since they retain their value when moving\r\n  ///   between records).\r\n  /// </param>\r\n  /// <param name=\"clearFlags\"></param>\r\n  invalidate(forceInvalidate: boolean, clearFlags: boolean): void {\r\n    let rec: Record = (<DataView>this._dataview).getCurrRec();\r\n\r\n    if (!this._isVirtual || this._virAsReal || this._initExp !== null || forceInvalidate) {\r\n      this._invalidValue = true;\r\n    }\r\n    if (clearFlags && rec !== null) {\r\n      rec.clearFlag(this._id, Record.FLAG_UPDATED);\r\n      rec.clearFlag(this._id, Record.FLAG_MODIFIED);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get Name of table\r\n  /// </summary>\r\n  public getTableName(): String {\r\n    if (this._tableName == null)\r\n      return \"\";\r\n    return this._tableName;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   for get VARNAME function use\r\n  ///   A string containing the table name where the variable originates,\r\n  ///   concatenated with '.' and the variable description of the variable in that table.\r\n  ///   If the variable is a virtual one, then the table name would indicate 'Virtual'.\r\n  /// </summary>\r\n  public getName(): string {\r\n    if (this._isParam)\r\n      return \"Parameter.\" + this.getVarName();\r\n    else if (this._isVirtual)\r\n      return \"Virtual.\" + this.getVarName();\r\n    else return this.getTableName() + \".\" + this.getVarName();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   test for a nullity\r\n  /// </summary>\r\n  public isNull(): boolean {\r\n    if ((<Task>super.getTask()).getEvalOldValues())\r\n      return this.isOriginalValueNull();\r\n    else if (this._invalidValue)\r\n      this.takeValFromRec();\r\n    return this._isNull;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  PrevIsNull(): boolean {\r\n    return this._prevIsNull;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   test for an modified flag\r\n  /// </summary>\r\n  isModified(): boolean {\r\n    let currRec: Record = (<DataView>this._dataview).getCurrRec();\r\n    return currRec.isFldModified(this._id);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the modified flag\r\n  ///   please note that clearing the flag is done explicitly\r\n  /// </summary>\r\n  setModified(): void {\r\n    let rec: Record = ((<DataView>this._dataview).getCurrRec());\r\n    rec.setFlag(this._id, Record.FLAG_MODIFIED);\r\n\r\n    // This flag will be set as FLAG_MODIFIED and never cleared. Qcr #926815\r\n    rec.setFlag(this._id, Record.FLAG_MODIFIED_ATLEAST_ONCE);\r\n    if (this.IsVirtual)\r\n      this.modifiedAtLeastOnce = true;\r\n    // the setting of the record modified flag is done explicitly\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the updated flag\r\n  ///   please note that clearing the flag is done explicitly\r\n  /// </summary>\r\n  setUpdated(): void {\r\n    let currRec: Record = (<DataView>this._dataview).getCurrRec();\r\n    currRec.setFlag(this._id, Record.FLAG_UPDATED);\r\n    currRec.setUpdated();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if this field is a parameter\r\n  /// </summary>\r\n  isParam(): boolean {\r\n    return this._isParam;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns if the field in evaluation process\r\n  /// </summary>\r\n  isInEvalProcess(): boolean {\r\n    return this._inEvalProcess;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the field has an init expression\r\n  /// </summary>\r\n  hasInitExp(): boolean {\r\n    return this._initExp !== null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the server recomputes this field\r\n  /// </summary>\r\n  isServerRcmp(): boolean {\r\n    return this._recompute !== null && this._recompute.isServerRcmp();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the picture of the field as a string\r\n  /// </summary>\r\n  getPicture(): string {\r\n    return this._picture;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the the id of the link this field belong to\r\n  ///   if does not belong to any link return -1\r\n  /// </summary>\r\n  getDataviewHeaderId(): number {\r\n    return this._dataviewHeaderId;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   returns whether the field belongs to a link or not\r\n  /// </summary>\r\n  get IsLinkField(): boolean {\r\n    return this._isLinkFld;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   evaluates and returns the init expression value of this field (null if there is non)\r\n  /// </summary>\r\n  public async getInitExpVal(res: RefParam<string>, isNull: RefParam<boolean>): Promise<void> {\r\n\r\n    if (this._initExp != null)\r\n      await this.EvaluateInitExpression(res, isNull);\r\n    else\r\n      res.value = this.getDefaultValue();\r\n  }\r\n\r\n/// <summary>\r\n  ///   sets the hasChangeEvent flag to TRUE\r\n  /// </summary>\r\n  setHasChangeEvent(): void {\r\n    this._hasChangeEvent = true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   retrieves the hasChangeEvent flag\r\n  /// </summary>\r\n  private getHasChangeEvent(): boolean {\r\n    return this._hasChangeEvent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set hasZoomHandler to true\r\n  /// </summary>\r\n  setHasZoomHandler(): void {\r\n    this._hasZoomHandler = true;\r\n  }\r\n\r\n  /// <returns> the hasZoomHandler\r\n  /// </returns>\r\n  getHasZoomHandler(): boolean {\r\n    return this._hasZoomHandler;\r\n  }\r\n\r\n/// <summary>\r\n  ///   returns true if in this field will cause invalidation of all rows in table\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isCauseTableInvalidation(): boolean {\r\n    return this._causeTableInvalidation;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set cause Table Invalidation member\r\n  /// </summary>\r\n  /// <param name = \"causeTableInvalidation\"></param>\r\n  causeTableInvalidation(causeTableInvalidation: boolean): void {\r\n    this._causeTableInvalidation = causeTableInvalidation;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   when value is null, get value that represent null\r\n  /// </summary>\r\n  /// <param name = \"checkNullArithmetic\"></param>\r\n  /// <returns></returns>\r\n  getValueForNull(checkNullArithmetic: boolean): string {\r\n    let val: string;\r\n    if (this.NullAllowed) {\r\n\r\n      if (checkNullArithmetic && super.getTask().getNullArithmetic() === Constants.NULL_ARITH_NULLIFY) {\r\n        val = null;\r\n      }\r\n      else {\r\n        if (this._nullValue === null) {\r\n          this._nullValue = super.getMagicDefaultValue();\r\n        }\r\n        val = this._nullValue;\r\n      }\r\n    }\r\n    else {\r\n      val = super.getMagicDefaultValue();\r\n    }\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the control which is attached to the field and resides on the same task\r\n  ///   of of the field\r\n  /// </summary>\r\n  public getCtrl(): MgControl {\r\n    let ctrl: MgControl;\r\n\r\n    if (this._controls != null) {\r\n      for (let i: number = 0; i < this._controls.length; i++) {\r\n        ctrl = <MgControl>this._controls.get_Item(i);\r\n        if (ctrl.getForm().getTask() === this.getTask())\r\n          return ctrl;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   update the display\r\n  /// </summary>\r\n  async updateDisplay(): Promise<void> {\r\n    await super.updateDisplayWithValue(this.getDispValue(), this.isNull());\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the value to display\r\n  /// </summary>\r\n  public getDispValue(): string {\r\n    if (this.isNull()) {\r\n      if (this._nullDisplay != null)\r\n        return this.getNullDisplay();\r\n      else return super.getMagicDefaultValue();\r\n    }\r\n    else return this.getValue(false);\r\n  }\r\n\r\n  /// <summary>\r\n  /// true, if range condition should be applied to the ield during compute\r\n  /// </summary>\r\n  get ShouldCheckRangeInCompute(): boolean {\r\n    return this.IsLinkField || (this.IsVirtual && (<DataView>this._dataview).HasMainTable);\r\n  }\r\n\r\n  IsForArgument(taskHasParameters: boolean): boolean {\r\n    // If we need a parameter and the field is not one\r\n    if (taskHasParameters) {\r\n      if (!this.isParam()) {\r\n        return false;\r\n      }\r\n    }\r\n    else {\r\n      if (!this.IsVirtual) {\r\n        return false;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n}\r\n"]}