@magic-xpa/gui 4.801.0-dev481.242 → 4.801.0-dev481.248

package/esm2020/src/management/gui/MgControlBase.mjs

@@ -0,0 +1,1873 @@
+import { ApplicationException, Debug, Exception, List, NNumber, NString, RefParam, StringBuilder, isNullOrUndefined } from '@magic-xpa/mscorelib';
+import { GuiFieldBase } from '../data/GuiFieldBase';
+import { ChoiceUtils, Constants, InternalInterface, MagicProperties, MgControlType, Misc, SEQ_2_STR, StorageAttribute, StorageAttributeCheck, StrUtil, UtilStrByteMode, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { PIC } from './PIC';
+import { PropTable } from './PropTable';
+import { ValidationDetails } from './ValidationDetails';
+import { FieldDef } from '../data/FieldDef';
+import { Property } from './Property';
+import { Manager } from '../../Manager';
+import { CommandType, HtmlProperties } from '../../GuiEnums';
+import { Commands } from '../../Commands';
+import { NUM_TYPE } from '../data/NUM_TYPE';
+import { PropInterface } from './PropInterface';
+import { Events } from '../../Events';
+import { EMPTY_DCREF } from '../data/DcValues';
+import { DisplayConvertor } from './DisplayConvertor';
+import { BlobType } from '../data/BlobType';
+import { VectorType } from '../data/VectorType';
+import { ObjectReference } from '../../util/ObjectReference';
+import { GuiConstants } from '../../GuiConstants';
+import { GuiControlPropertyAdapter } from './GuiControlPropertyAdapter';
+import { FocusManager } from '../../FocusManager';
+export class MgControlBase extends GuiControlPropertyAdapter {
+    constructor(type, parentMgForm, parentControl) {
+        super();
+        this._ditIdx = 0;
+        this._linkedControls = null;
+        this._field = null;
+        this._picStr = null;
+        this._choiceDisps = null;
+        this._choiceLayerList = null;
+        this._choiceLinks = null;
+        this._choiceNums = null;
+        this._containerDitIdx = -1;
+        this._currReadOnly = null;
+        this._dataCtrl = false;
+        this._dcTableRefs = null;
+        this._firstRefreshProperties = true;
+        this._form = null;
+        this._hasValidItmAndDispVal = false;
+        this._id = -1;
+        this._controlIsn = -1;
+        this._linkedParentDitIdx = -1;
+        this._orgChoiceDisps = null;
+        this._parentTable = null;
+        this._pic = null;
+        this._picExpExists = false;
+        this._prevIsNulls = null;
+        this._prevPicExpResult = null;
+        this._prevValues = null;
+        this._propTab = null;
+        this._range = null;
+        this._rangeChanged = false;
+        this._rtfVal = NString.Empty;
+        this._valExpId = 0;
+        this._vd = null;
+        this._dcValId = -2;
+        this.parent = 0;
+        this.veeIndx = 0;
+        this.DNObjectReferenceField = null;
+        this.SourceTableReference = null;
+        this.ClipBoardDataExists = false;
+        this.DataType = StorageAttribute.NONE;
+        this.KeyStrokeOn = false;
+        this.ModifiedByUser = false;
+        this.Value = null;
+        this.IsNull = false;
+        this.forceRefresh = false;
+        this.RefreshOnVisible = false;
+        this.InControl = false;
+        this.ValidateControl = false;
+        this.PromptHelp = null;
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        this.constructor_1(type, parentMgForm, parentControl);
+    }
+    set Form(value) {
+        this._form = value;
+        this.GuiMgForm = value;
+    }
+    get Form() {
+        return this._form;
+    }
+    get Id() {
+        return this._id;
+    }
+    get ControlIsn() {
+        return this._controlIsn;
+    }
+    constructor_0() {
+        this._linkedControls = new List();
+        this.DataType = StorageAttribute.NONE;
+    }
+    constructor_1(type, parentMgForm, parentControl) {
+        this.constructor_0();
+        this.initReferences(parentMgForm);
+        this.Type = type;
+        this._containerDitIdx = parentControl;
+        this._linkedParentDitIdx = parentControl;
+        this._propTab = new PropTable(this);
+        this.createArrays(false);
+    }
+    get UniqueName() {
+        return this.Name;
+    }
+    get TaskTag() {
+        return this.Form.getTask().getTaskTag();
+    }
+    checkIfExistProp(propId) {
+        let exist = false;
+        if (this._propTab !== null) {
+            let propById = this._propTab.getPropById(propId);
+            exist = (propById !== null);
+        }
+        return exist;
+    }
+    getProp(propId) {
+        let prop = null;
+        if (this._propTab !== null) {
+            prop = this._propTab.getPropById(propId);
+            if (prop === null) {
+                prop = Property.getDefaultProp(propId, 'C', this);
+                if (prop !== null) {
+                    this._propTab.addProp(prop);
+                }
+            }
+        }
+        return prop;
+    }
+    getForm() {
+        return this.Form;
+    }
+    getCompIdx() {
+        return this.getForm().getTask().getCompIdx();
+    }
+    IsFirstRefreshOfProps() {
+        return this._firstRefreshProperties;
+    }
+    async EvaluateExpression(expId, resType, length, contentTypeUnicode, resCellType, alwaysEvaluate, wasEvaluated) {
+        return await this.getForm().getTask().EvaluateExpression(expId, resType, length, contentTypeUnicode, resCellType, alwaysEvaluate, wasEvaluated);
+    }
+    GetExpressionStorage(expId) {
+        return this.getForm().getTask().GetExpressionStorage(expId);
+    }
+    GetComputedProperty(propId) {
+        let prop = null;
+        if (this._propTab !== null)
+            prop = this._propTab.getPropById(propId);
+        return prop;
+    }
+    initReferences(mgForm) {
+        this.Form = mgForm;
+    }
+    createArrays(forceCreateArrays) {
+        if (this._firstRefreshProperties || forceCreateArrays) {
+            if (this.SupportsDataSource()) {
+                this._dcTableRefs = new List();
+            }
+            this._prevValues = new List();
+            if (!forceCreateArrays) {
+                this._currReadOnly = new List();
+            }
+            this._choiceDisps = new List();
+            this._orgChoiceDisps = new List();
+            this._choiceLinks = new List();
+            this._choiceNums = new List();
+            this._prevIsNulls = new List();
+            this._choiceLayerList = new List();
+            if (!this.IsRepeatable && !super.isTableControl()) {
+                this.updateArrays(1);
+            }
+        }
+    }
+    async SetFocus(ctrl, line, activateForm) {
+        await FocusManager.SetFocus(ctrl.getForm().getTask(), ctrl, line, activateForm);
+    }
+    InsertArrays(idx, count) {
+        this._prevValues.InsertRange(new Array(count));
+        this._prevIsNulls.InsertRange(new Array(count));
+        this._currReadOnly.InsertRange(new Array(count));
+        this._choiceDisps.InsertRange(new Array(count));
+        this._orgChoiceDisps.InsertRange(new Array(count));
+        this._choiceLinks.InsertRange(new Array(count));
+        this._choiceLayerList.InsertRange(new Array(count));
+        this._choiceNums.InsertRange(new Array(count));
+        if (this.SupportsDataSource())
+            this._dcTableRefs.InsertRange(new Array(count));
+        this._propTab.InsertPrevValueArray(count);
+    }
+    updateArrays(newSize) {
+        this._prevValues.SetSize(newSize);
+        this._prevIsNulls.SetSize(newSize);
+        this._currReadOnly.SetSize(newSize);
+        this._choiceDisps.SetSize(newSize);
+        this._orgChoiceDisps.SetSize(newSize);
+        this._choiceLinks.SetSize(newSize);
+        this._choiceLayerList.SetSize(newSize);
+        this._choiceNums.SetSize(newSize);
+        if (this.SupportsDataSource()) {
+            this._dcTableRefs.SetSize(newSize);
+        }
+        this._propTab.updatePrevValueArray(newSize);
+    }
+    updatePrevValArrays(newSize) {
+        this._propTab.updatePrevValueArray(newSize);
+    }
+    fillData(mgForm, ditIdx, parser) {
+        if (this.Form === null) {
+            this.initReferences(mgForm);
+        }
+        this._ditIdx = ditIdx;
+        while (this.initInnerObjects(parser.getNextTag(), parser)) {
+        }
+        if (this.DataType === StorageAttribute.BLOB && this._picStr === null) {
+            this._picStr = "";
+        }
+        if (this._picStr !== null && typeof this.DataType !== "undefined") {
+            this.setPIC(this._picStr);
+        }
+        else {
+            switch (this.Type) {
+                case MgControlType.CTRL_TYPE_IMAGE:
+                case MgControlType.CTRL_TYPE_BROWSER:
+                case MgControlType.CTRL_TYPE_BUTTON:
+                    if (this.DataType === StorageAttribute.NONE)
+                        this.DataType = StorageAttribute.ALPHA;
+                    break;
+                case MgControlType.CTRL_TYPE_TABLE:
+                case MgControlType.CTRL_TYPE_COLUMN:
+                case MgControlType.CTRL_TYPE_SUBFORM:
+                case MgControlType.CTRL_TYPE_GROUP:
+                case MgControlType.CTRL_TYPE_FRAME_SET:
+                case MgControlType.CTRL_TYPE_FRAME_FORM:
+                case MgControlType.CTRL_TYPE_CONTAINER:
+                case MgControlType.CTRL_TYPE_LINE:
+                    break;
+                default:
+                    Events.WriteExceptionToLog(NString.Format("in Control.fillData(): missing datatype or picture string for control: {0}", this.Name));
+                    break;
+            }
+        }
+        if (super.isTableControl()) {
+            this.Form.setTableCtrl(this);
+        }
+        this.createArrays(false);
+    }
+    initInnerObjects(foundTagName, parser) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === XMLConstants.MG_TAG_PROP) {
+            if (this._propTab === null)
+                this._propTab = new PropTable(this);
+            this._propTab.fillData(this, 'C', parser);
+        }
+        else if (foundTagName === XMLConstants.MG_TAG_CONTROL)
+            this.parseAttributes(parser);
+        else if (foundTagName === "SourceTable")
+            this.ParseSourceTable(parser);
+        else if (foundTagName === "/" + XMLConstants.MG_TAG_CONTROL) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else {
+            Events.WriteExceptionToLog(NString.Format("There is no such tag in Control. Insert else if to Control.initInnerObjects for {0}", foundTagName));
+            return false;
+        }
+        return true;
+    }
+    ParseSourceTable(parser) {
+        parser.setCurrIndex2EndOfTag();
+        let objRefStr = parser.ReadToEndOfCurrentElement();
+        let sourceTableReference = ObjectReference.FromXML(objRefStr.trim());
+        this.SourceTableReference = sourceTableReference;
+        parser.setCurrIndex2EndOfTag();
+    }
+    parseAttributes(parser) {
+        let endContext = parser.getXMLdata().indexOf(">", parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(XMLConstants.MG_TAG_CONTROL) + XMLConstants.MG_TAG_CONTROL.length);
+            let tokens = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            for (let i = 0; i < tokens.length; i = i + 2) {
+                let attribute = tokens.get_Item(i);
+                let valueStr = tokens.get_Item(i + 1);
+                this.SetAttribute(attribute, valueStr);
+            }
+            parser.setCurrIndex(endContext + 1);
+        }
+        else {
+            Events.WriteExceptionToLog("in Control.FillName() out of string bounds");
+        }
+    }
+    SetAttribute(attribute, valueStr) {
+        let isTagProcessed = true;
+        switch (attribute) {
+            case XMLConstants.MG_ATTR_TYPE:
+                this.Type = valueStr[0];
+                break;
+            case XMLConstants.MG_ATTR_DATA_CTRL:
+                this._dataCtrl = XmlParser.getBoolean(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_LINKED_PARENT:
+                this.setLinkedParentIdx(XmlParser.getInt(valueStr));
+                break;
+            case XMLConstants.MG_ATTR_CONTAINER:
+                this.setContainer(XmlParser.getInt(valueStr));
+                break;
+            case XMLConstants.MG_ATTR_ID:
+                this._id = XmlParser.getInt(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_CONTROL_ISN:
+                this._controlIsn = XmlParser.getInt(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_IS_MODAL:
+                this._isModal = XmlParser.getBoolean(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_CONTROL_Z_ORDER:
+                break;
+            case XMLConstants.MG_HOR_ALIGMENT_IS_INHERITED:
+                break;
+            default:
+                isTagProcessed = false;
+                break;
+        }
+        return isTagProcessed;
+    }
+    setImage() {
+        let newVal = this.Value;
+        if (newVal === null || this.IsNull) {
+            newVal = "";
+        }
+        if (this.DataType === StorageAttribute.BLOB) {
+        }
+        else {
+            this.setImageWithFileName(newVal);
+        }
+    }
+    setImageWithFileName(fileName) {
+        if (fileName === null) {
+            fileName = "";
+        }
+        fileName = Events.TranslateLogicalName(fileName);
+        if (!Misc.IsWebUrl(fileName))
+            fileName = "./assets/images/" + fileName;
+        if (this.IsImageButton()) {
+            Commands.addOperationWithLine(CommandType.SET_STYLE, this, 0, MagicProperties.ImageFile, fileName);
+        }
+        else {
+            Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.Image, fileName);
+            Commands.addValueWithLine(CommandType.SET_VALUE, this, this.getDisplayLine(false), fileName);
+        }
+    }
+    setContainer(containerIdx) {
+        this._containerDitIdx = containerIdx;
+        let container = null;
+        if (this._containerDitIdx !== -1) {
+            container = this.Form.getCtrl(this._containerDitIdx);
+        }
+        if (container !== null && container.Type === MgControlType.CTRL_TYPE_TABLE) {
+            this._parentTable = container;
+        }
+        this.IsRepeatable = (this._parentTable !== null && !super.isColumnControl());
+    }
+    getName() {
+        return this.Name;
+    }
+    getLinkedControls() {
+        return this._linkedControls;
+    }
+    isRepeatable() {
+        return this.IsRepeatable;
+    }
+    IsModal() {
+        return this._isModal;
+    }
+    getDisplayLine(useLineForItems) {
+        let line = 0;
+        if (this.IsRepeatable || (useLineForItems && super.isTableControl())) {
+            line = this.Form.DisplayLine;
+        }
+        return line;
+    }
+    isVisible() {
+        let result = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_VISIBLE, true);
+        if (result) {
+            result = this.isParentPropValue(PropInterface.PROP_TYPE_VISIBLE);
+        }
+        return result;
+    }
+    isEnabled() {
+        return this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_ENABLED, true);
+    }
+    isModifiable() {
+        let modifiable = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MODIFIABLE, true);
+        let taskInQuery = this.getForm().getTask().getMode() === Constants.TASK_MODE_QUERY;
+        let modifyInQuery = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MODIFY_IN_QUERY, false);
+        let result = modifiable && (modifyInQuery || !taskInQuery);
+        if (result && this._field != null) {
+            result = (this._field.DbModifiable || this.getForm().getTask().getMode() === Constants.TASK_MODE_CREATE);
+        }
+        return result;
+    }
+    getDcVals() {
+        let dataView = this.getForm().getTask().DataView;
+        let dcv = null;
+        if (this._dcValId === EMPTY_DCREF) {
+            dcv = ((this.DataType === StorageAttribute.BLOB_VECTOR) ? dataView.getEmptyChoiceForVectors() : dataView.getEmptyChoice());
+        }
+        else {
+            if (this._dcValId > -1) {
+                dcv = dataView.getDcValues(this._dcValId);
+            }
+        }
+        return dcv;
+    }
+    getPrevIsNull() {
+        let line = this.getDisplayLine(true);
+        let currObj = this._prevIsNulls.get_Item(line);
+        let curr;
+        if (currObj === null) {
+            curr = false;
+            this._prevIsNulls.set_Item(line, curr);
+        }
+        else {
+            curr = currObj;
+        }
+        return curr;
+    }
+    setPrevIsNull(newValue) {
+        this._prevIsNulls.set_Item(this.getDisplayLine(true), newValue);
+    }
+    setPIC(picStr) {
+        if (super.isButton()) {
+            this._picStr = (super.IsImageButton() ? "" + XMLConstants.FILE_NAME_SIZE.toString() : Events.Translate(picStr));
+        }
+        else {
+            this._picStr = picStr;
+        }
+        this._pic = new PIC(this._picStr, this.DataType, this.getForm().getTask().getCompIdx());
+        if (this._dataCtrl && this._picStr.indexOf('H') > -1) {
+            this._pic.setHebrew();
+        }
+    }
+    getPIC() {
+        return this._pic;
+    }
+    getParent() {
+        let retParent = this.Form;
+        if (this._containerDitIdx !== -1) {
+            retParent = this.Form.getCtrl(this._containerDitIdx);
+        }
+        else {
+            if (this.Form.isSubForm()) {
+                retParent = this.Form.getSubFormCtrl();
+            }
+        }
+        return retParent;
+    }
+    getField() {
+        return this._field;
+    }
+    setField(fieldOrFieldStrID) {
+        if (fieldOrFieldStrID === null || fieldOrFieldStrID instanceof GuiFieldBase) {
+            this.setField_0(fieldOrFieldStrID);
+            return;
+        }
+        this.setField_1(fieldOrFieldStrID);
+    }
+    setField_0(field) {
+        this._field = field;
+        if (field !== null) {
+            this._field.SetControl(this);
+        }
+    }
+    setField_1(fieldStrID) {
+        let returnField = this.getFieldByValueStr(fieldStrID);
+        if (returnField !== null) {
+            this._field = returnField;
+            this._field.SetControl(this);
+            return;
+        }
+        throw new ApplicationException("in Control.setField(): illegal field identifier: " + fieldStrID);
+    }
+    setPicStr(format, expId) {
+        this._picStr = format;
+        if (expId > 0) {
+            this._picExpExists = true;
+        }
+    }
+    setRange(newRange) {
+        this._range = newRange;
+        this._vd = null;
+    }
+    setValExp(expId) {
+        this._valExpId = expId;
+    }
+    buildCopyPicture(oldVal, newVal) {
+        if (super.isTableControl() || super.isColumnControl()) {
+            return null;
+        }
+        else {
+            let copyVD = this.getCopyOfVD();
+            copyVD.setValue(newVal);
+            copyVD.setOldValue(oldVal);
+            return copyVD;
+        }
+    }
+    getCopyOfVD() {
+        let result;
+        if (this._vd === null) {
+            result = new ValidationDetails(this.Value, this.Value, this._range, this._pic, this);
+        }
+        else {
+            result = new ValidationDetails(this._vd);
+        }
+        return result;
+    }
+    getRanges() {
+        return this._range;
+    }
+    getRangedValue(newVal) {
+        let vd;
+        vd = this.buildCopyPicture(this.Value, newVal);
+        vd.evaluate();
+        let val = vd.getDispValue();
+        return (val.toString());
+    }
+    validate(newVal) {
+        let vd;
+        let modified = this.ModifiedByUser;
+        this.ModifiedByUser = true;
+        vd = this.buildCopyPicture(this.Value, newVal);
+        vd.evaluate();
+        this.ModifiedByUser = modified;
+        if (vd.ValidationFailed)
+            return vd.ErrorMessage;
+        else
+            return null;
+    }
+    getFieldByValueStr(valueStr) {
+        let refParent = new RefParam(this.parent);
+        let refVeeIndx = new RefParam(this.veeIndx);
+        let ret = this.getForm().getTask().getFieldByValueStr(valueStr, refParent, refVeeIndx);
+        this.parent = refParent.value;
+        this.veeIndx = refVeeIndx.value;
+        return ret;
+    }
+    hasContainer() {
+        return this._containerDitIdx !== -1;
+    }
+    getLayer() {
+        return this.Layer;
+    }
+    computePIC(picExpResult) {
+        let picResult = (picExpResult !== null && super.isButton()) ? Events.Translate(picExpResult) : picExpResult;
+        if (this._prevPicExpResult === null || !(this._prevPicExpResult === picResult)) {
+            this._pic = new PIC(picResult, this.DataType, this.getForm().getTask().getCompIdx());
+            this._prevPicExpResult = picResult;
+        }
+        return this._pic;
+    }
+    getCurrentIndexOfChoice() {
+        let selectedIndice = [-1];
+        let val = this.Value;
+        if (!NString.IsNullOrEmpty(val)) {
+            let array2 = val.split(',');
+            selectedIndice = new Array(array2.length);
+            for (let iCtr = 0; iCtr < array2.length; iCtr = iCtr + 1) {
+                let num = NNumber.Parse(array2[iCtr]);
+                selectedIndice[iCtr] = ((num >= 0) ? num : -1);
+            }
+        }
+        return selectedIndice;
+    }
+    IsMultipleSelectionListBox() {
+        return super.isListBox();
+    }
+    IsDateTimePicture() {
+        return this._pic.getAttr() === StorageAttribute.DATE || this._pic.getAttr() === StorageAttribute.TIME;
+    }
+    SupportsDataSource() {
+        return super.isSelectionCtrl() || super.isTabControl() || super.isRadio() || this.HasAutocomplete();
+    }
+    HasAutocomplete() {
+        if (super.isTextControl())
+            return this.getProp(PropInterface.PROP_TYPE_AUTO_COMPLETE_MODE_WC).GetComputedValueBoolean();
+        return false;
+    }
+    async getIndexOfChoice(mgVal, line, isNull) {
+        let splitCommaSeperatedVals = this.IsMultipleSelectionListBox();
+        await this.computeChoice(line);
+        let isVectorValue = this.getField() !== null && this.getField().getType() === StorageAttribute.BLOB_VECTOR;
+        return this.getDcVals().getIndexOf(mgVal, isVectorValue, isNull, this._choiceLinks.get_Item(line), this._choiceNums.get_Item(line), splitCommaSeperatedVals);
+    }
+    async getDispVals(line, execComputeChoice) {
+        if (execComputeChoice) {
+            await this.computeChoice(line);
+        }
+        if (super.isTabControl()) {
+            return this._orgChoiceDisps.get_Item(line);
+        }
+        else {
+            return this._choiceDisps.get_Item(line);
+        }
+    }
+    emptyChoice(line) {
+        let value = new Array(0);
+        this._choiceDisps.set_Item(line, value);
+        this._orgChoiceDisps.set_Item(line, value);
+        this._choiceLinks.set_Item(line, value);
+        this._choiceLayerList.set_Item(line, value);
+    }
+    async computeChoice(line) {
+        let fromHelp = [
+            "\\\\", "\\-", "\\,"
+        ];
+        let toHelp = [
+            "XX", "XX", "XX"
+        ];
+        let task = this.getForm().getTask();
+        let dataView = task.DataView;
+        let dcv = dataView.getDcValues(this._dcValId);
+        let currDcId = this.getDcRef();
+        let choiceDispStr = null;
+        let choiceLinkStr = "";
+        let optionsValid = true;
+        let trimToLength = -1;
+        let dataType = this.DataType;
+        let isItemsListTreatedAsDisplayList = false;
+        try {
+            if (this._choiceLinks.get_Item(line) === null || (this.isDataCtrl() && currDcId !== this._dcValId)) {
+                if (dataType === StorageAttribute.BLOB_VECTOR) {
+                    dataType = this.getField().getCellsType();
+                }
+                let dispVals = dcv.getDispVals();
+                let dispProp = this.getProp(PropInterface.PROP_TYPE_DISPLAY_LIST);
+                let linkProp = this.getProp(PropInterface.PROP_TYPE_LABEL);
+                if (dispProp !== null) {
+                    choiceDispStr = await dispProp.getValue();
+                }
+                if (linkProp !== null) {
+                    choiceLinkStr = await linkProp.getValue();
+                }
+                if (choiceLinkStr === null || StrUtil.rtrim(choiceLinkStr).length === 0) {
+                    choiceLinkStr = "";
+                }
+                if (choiceDispStr === null || StrUtil.rtrim(choiceDispStr).length === 0) {
+                    if (!this.isDataCtrl() || dispVals === null || dispVals.length === 0) {
+                        choiceDispStr = choiceLinkStr;
+                    }
+                    else {
+                        choiceDispStr = (choiceLinkStr = "");
+                    }
+                    isItemsListTreatedAsDisplayList = true;
+                }
+                choiceDispStr = Events.Translate(choiceDispStr);
+                if (dataType === StorageAttribute.NUMERIC) {
+                    choiceLinkStr = StrUtil.searchAndReplace(choiceLinkStr, "\\-", "-");
+                }
+                let helpStr = StrUtil.searchAndReplace(choiceLinkStr, fromHelp, toHelp);
+                let sTok = StrUtil.tokenize(helpStr, ",");
+                let linkSize = (helpStr !== "") ? sTok.length : 0;
+                let helpStrDisp = StrUtil.searchAndReplace(choiceDispStr, fromHelp, toHelp);
+                sTok = StrUtil.tokenize(helpStrDisp, ",");
+                let displaySize = (helpStrDisp !== "") ? sTok.length : 0;
+                if (linkSize !== displaySize && displaySize > 0) {
+                    choiceDispStr = choiceLinkStr;
+                    isItemsListTreatedAsDisplayList = true;
+                }
+                let size = linkSize;
+                let choiceLink = new Array(size);
+                this._choiceLinks.set_Item(line, choiceLink);
+                if (dataType === StorageAttribute.NUMERIC || dataType === StorageAttribute.DATE || dataType === StorageAttribute.TIME) {
+                    this._choiceNums.set_Item(line, new Array(size));
+                }
+                let orgChoiceDisp = ChoiceUtils.GetDisplayListFromString(choiceDispStr, false, true, !isItemsListTreatedAsDisplayList);
+                this._orgChoiceDisps.set_Item(line, orgChoiceDisp);
+                let choiceDisp = ChoiceUtils.GetDisplayListFromString(choiceDispStr, super.isSelectionCtrl() || super.isTabControl(), true, !isItemsListTreatedAsDisplayList);
+                this._choiceDisps.set_Item(line, choiceDisp);
+                if (this.getField() !== null) {
+                    trimToLength = this.getField().getSize();
+                }
+                let token = null;
+                let helpToken = null;
+                let tokenBuffer;
+                for (let i = 0, currPos = 0, nextPos = 0; i < size && optionsValid; i++) {
+                    nextPos = currPos;
+                    nextPos = helpStr.indexOf(',', nextPos);
+                    if (nextPos === currPos)
+                        token = helpToken = "";
+                    else if (nextPos === -1) {
+                        token = choiceLinkStr.substr(currPos);
+                        helpToken = helpStr.substr(currPos);
+                    }
+                    else {
+                        token = choiceLinkStr.substr(currPos, (nextPos) - (currPos));
+                        helpToken = helpStr.substr(currPos, (nextPos) - (currPos));
+                    }
+                    currPos = nextPos + 1;
+                    switch (dataType) {
+                        case StorageAttribute.ALPHA:
+                        case StorageAttribute.MEMO:
+                        case StorageAttribute.UNICODE:
+                        case StorageAttribute.BLOB_VECTOR:
+                            token = StrUtil.ltrim(token);
+                            helpToken = StrUtil.ltrim(helpToken);
+                            if (helpToken.indexOf('\\') >= 0) {
+                                tokenBuffer = new StringBuilder();
+                                for (let tokenPos = 0; tokenPos < helpToken.length; tokenPos++)
+                                    if (helpToken[tokenPos] !== '\\')
+                                        tokenBuffer.Append(token[tokenPos]);
+                                    else if (tokenPos === helpToken.length - 1)
+                                        tokenBuffer.Append(' ');
+                                token = tokenBuffer.ToString();
+                            }
+                            token = StrUtil.makePrintableTokens(token, SEQ_2_STR);
+                            if (this.isSelectionCtrl() || this.isTabControl())
+                                token = ChoiceUtils.RemoveAcclCharFromOptions(new StringBuilder(token));
+                            if (UtilStrByteMode.isLocaleDefLangDBCS() && dataType === StorageAttribute.ALPHA) {
+                                if (trimToLength !== -1 && UtilStrByteMode.lenB(token) > trimToLength)
+                                    token = UtilStrByteMode.leftB(token, trimToLength);
+                            }
+                            else {
+                                if (trimToLength !== -1 && token.length > trimToLength)
+                                    token = token.substr(0, trimToLength);
+                            }
+                            choiceLink[i] = token;
+                            break;
+                        case StorageAttribute.NUMERIC:
+                        case StorageAttribute.DATE:
+                        case StorageAttribute.TIME:
+                            let picture = PIC.buildPicture(dataType, token, task.getCompIdx(), false);
+                            optionsValid = this.optionIsValid(token);
+                            choiceLink[i] = DisplayConvertor.Instance.disp2mg(token.trim(), picture, task.getCompIdx(), BlobType.CONTENT_TYPE_UNKNOWN);
+                            ((this._choiceNums.get_Item(line)))[i] = new NUM_TYPE(choiceLink[i]);
+                            break;
+                        case StorageAttribute.BOOLEAN:
+                            choiceLink[i] = (1 - i).toString();
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                if (!optionsValid)
+                    this.emptyChoice(line);
+            }
+        }
+        catch (ex) {
+            if (ex instanceof Exception) {
+                optionsValid = false;
+                this.emptyChoice(line);
+                Events.WriteExceptionToLog(NString.Format("{0} : {1}", ex.GetType(), ex.Message));
+            }
+            else
+                throw ex;
+        }
+        this._hasValidItmAndDispVal = optionsValid;
+    }
+    getTopMostForm() {
+        return this.getForm().getTopMostForm();
+    }
+    setUrl() {
+        Commands.addValueWithLine(CommandType.SET_VALUE, this, 0, this.Value);
+    }
+    async getMgValue(dispVal) {
+        let mgVal = null;
+        if (super.isCheckBox()) {
+            mgVal = dispVal ? "1" : "0";
+        }
+        else {
+            if (super.isSelectionCtrl() || super.isTabControl() || super.isRadio()) {
+                let line = this.getDisplayLine(true);
+                if (line < 0)
+                    line = 0;
+                if (typeof dispVal === "number")
+                    dispVal = dispVal.toString();
+                if (Array.isArray(dispVal))
+                    dispVal = dispVal.join(',').toString();
+                if (dispVal === "") {
+                    mgVal = dispVal;
+                }
+                else {
+                    mgVal = await this.getLinkValue(dispVal, line);
+                }
+                if (mgVal === null) {
+                    let isNull = false;
+                    let refMgVal = new RefParam(mgVal);
+                    let refIsNull = new RefParam(isNull);
+                    if (this._field !== null) {
+                        mgVal = refMgVal.value;
+                    }
+                }
+            }
+            else {
+                let blobContentType = (this._field !== null) ? this._field.getContentType() : BlobType.CONTENT_TYPE_UNKNOWN;
+                mgVal = DisplayConvertor.Instance.disp2mg(dispVal, this._pic, this.getForm().getTask().getCompIdx(), blobContentType);
+            }
+        }
+        return mgVal;
+    }
+    async getLinkValue(selectedIndice, line) {
+        let size = 0;
+        let result = NString.Empty;
+        let temp = new List();
+        await this.computeChoice(line);
+        let choiceLink = this._choiceLinks.get_Item(line);
+        if (choiceLink !== null) {
+            size = choiceLink.length;
+        }
+        let linkIndice = this.getLinkIdxFromLayer(Misc.GetIntArray(selectedIndice));
+        let array2 = linkIndice;
+        for (let i = 0; i < array2.length; i = i + 1) {
+            let idx = array2[i];
+            if (idx >= size) {
+                let dcVals = this.getDcVals();
+                temp.push(dcVals.getLinkValue(idx - size));
+            }
+            else {
+                if (idx >= 0 && idx < choiceLink.length) {
+                    temp.push(choiceLink[idx]);
+                }
+                else {
+                    temp.push(null);
+                }
+            }
+        }
+        if (this.DataType === StorageAttribute.BLOB_VECTOR) {
+            let vectorType = new VectorType(this.getField());
+            for (let indx = 0; indx < temp.length; indx = indx + 1) {
+                vectorType.setVecCell(indx + 1, temp.get_Item(indx), temp.get_Item(indx) === null);
+            }
+            result = vectorType.toString();
+        }
+        else {
+            if (temp.length > 1) {
+                result = temp.join(",");
+            }
+            else {
+                result = temp.get_Item(0);
+            }
+        }
+        return result;
+    }
+    setText() {
+        let displayLine = this.getDisplayLine(true);
+        let mlsTranslatedValue = this.Value;
+        if (super.isButton()) {
+            mlsTranslatedValue = Events.Translate(this.Value);
+        }
+        if (this.isTextControl() || this.isButton())
+            Commands.addValueWithLine(CommandType.SET_VALUE, this, displayLine, mlsTranslatedValue);
+        else
+            Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, displayLine, HtmlProperties.Text, mlsTranslatedValue);
+    }
+    setRadioChecked(index) {
+        Commands.addValueWithLine(CommandType.SET_VALUE, this, this.getDisplayLine(false), index);
+        Commands.beginInvoke();
+        if (index !== GuiConstants.DEFAULT_VALUE_INT) {
+            this.setControlToFocus();
+        }
+    }
+    setControlToFocus() {
+        if (this.getField() !== null) {
+            this.getField().ControlToFocus = this;
+        }
+    }
+    setCheckBoxValue(line, mgVal) {
+        let checkState = DisplayConvertor.toBoolean(mgVal);
+        Commands.addValueWithLine(CommandType.SET_VALUE, this, line, checkState);
+    }
+    async refreshAndSetItemListByDataSource(line, valueChanged) {
+        if (this.SupportsDataSource()) {
+            let currDcId = this.getDcRef();
+            if (this._rangeChanged) {
+                valueChanged = true;
+            }
+            this._rangeChanged = false;
+            if (this.isDataCtrl() && currDcId !== this._dcValId) {
+                valueChanged = true;
+                await this.refreshAndSetItemsList(line, true);
+                this.setDcRef(this._dcValId);
+            }
+        }
+        return valueChanged;
+    }
+    setDcRef(dcId) {
+        this._dcTableRefs.set_Item(this.getDcLineNum(), dcId);
+    }
+    setImageList(url) {
+    }
+    async updatePropertyLogicNesting(propId, commandType, val, updateThis) {
+        if (updateThis) {
+            Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), commandType === CommandType.PROP_SET_VISIBLE ? HtmlProperties.Visible : HtmlProperties.Enabled, val);
+        }
+        await this.updateChildrenPropValue(propId, commandType, val);
+    }
+    SetEnabled(val) {
+        Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.Enabled, val);
+    }
+    async updateChildrenPropValue(propId, commandType, val) {
+        if (!super.isTableControl()) {
+            for (let i = 0; i < this._linkedControls.length; i = i + 1) {
+                let child = this._linkedControls.get_Item(i);
+                if (child.IsFirstRefreshOfProps())
+                    continue;
+                let childValue = (child.GetComputedBooleanProperty(propId, true));
+                childValue = childValue && val;
+                let childOnCurrentLayer = this.isChildOnCurrentLayer(child);
+                if (commandType === CommandType.PROP_SET_VISIBLE) {
+                    if (childValue) {
+                        childValue = childOnCurrentLayer;
+                    }
+                    await child.updateChildrenPropValue(propId, commandType, childValue);
+                }
+            }
+            if (super.isSubform()) {
+                await this.updateSubformChildrenPropValue(propId, commandType, val);
+            }
+        }
+    }
+    isDescendentOfControl(control) {
+        let isContained = false;
+        if (control !== null) {
+            let parent = this.getParent();
+            if (parent instanceof MgControlBase) {
+                if (parent === control) {
+                    isContained = true;
+                }
+                else {
+                    let parentControl = ((parent instanceof MgControlBase) ? parent : null);
+                    if (control.Type === MgControlType.CTRL_TYPE_COLUMN && parentControl !== null && parentControl.Type === MgControlType.CTRL_TYPE_TABLE && control.Layer === this.Layer)
+                        isContained = true;
+                    else
+                        isContained = (parent.isDescendentOfControl(control));
+                }
+            }
+        }
+        return isContained;
+    }
+    updateSubformChildrenPropValue(propId, commandType, val) {
+    }
+    isChildOnCurrentLayer(child) {
+        let ret = true;
+        if (super.isChoiceControl()) {
+            let parentLayer = 0;
+            if (this.Value !== null) {
+                parentLayer = this.getCurrentLinkIdx() + 1;
+            }
+            let layer = child.getLayer();
+            if (parentLayer !== layer && layer > 0) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+    getCurrentLinkIdx() {
+        let currLinkIdx = 0;
+        if (super.isChoiceControl() || this.HasAutocomplete()) {
+            let currentLayers = this.getCurrentIndexOfChoice();
+            let currLinkIndice = this.getLinkIdxFromLayer(currentLayers);
+            currLinkIdx = currLinkIndice[0];
+        }
+        return currLinkIdx;
+    }
+    getLayerFromLinkIdx(indice) {
+        let layers = new Array(indice.length);
+        for (let iCtr = 0; iCtr < indice.length; iCtr = iCtr + 1) {
+            let idx = indice[iCtr];
+            layers[iCtr] = idx;
+            if (super.isTabControl() && idx >= 0) {
+                let line = this.getDisplayLine(false);
+                if (line < 0) {
+                    line = 0;
+                }
+                let layerList = this._choiceLayerList.get_Item(line);
+                if (layerList !== null && layerList.length > 0) {
+                    layers[iCtr] = layerList.indexOf((idx + 1).toString());
+                }
+            }
+        }
+        return layers;
+    }
+    getLinkIdxFromLayer(layers) {
+        let linkIndice = new Array(layers.length);
+        for (let iCtr = 0; iCtr < layers.length; iCtr = iCtr + 1) {
+            let layer = layers[iCtr];
+            linkIndice[iCtr] = layer;
+            if (super.isTabControl()) {
+                if (layer < 0) {
+                    linkIndice[iCtr] = 0;
+                }
+                else {
+                    let line = this.getDisplayLine(false);
+                    if (line < 0) {
+                        line = 0;
+                    }
+                    let layerList = this._choiceLayerList.get_Item(line);
+                    if (layerList !== null && typeof layerList !== "undefined" && layerList.length !== 0 && layer < layerList.length) {
+                        linkIndice[iCtr] = NNumber.Parse(layerList[layer]) - 1;
+                    }
+                }
+            }
+        }
+        return linkIndice;
+    }
+    isParentPropValue(propId) {
+        let column = this.Form.getControlColumn(this);
+        let parent = this.getLinkedParent(true);
+        let result;
+        if (parent === null) {
+            result = true;
+        }
+        else {
+            if (!parent.GetComputedBooleanProperty(propId, true)) {
+                result = false;
+            }
+            else {
+                if (!parent.isChildOnCurrentLayer(this)) {
+                    result = false;
+                }
+                else {
+                    result = (!(column !== null && !column.GetComputedBooleanProperty(propId, true)) && parent.isParentPropValue(propId));
+                }
+            }
+        }
+        return result;
+    }
+    getLinkedParent(checkSubformFather) {
+        if (this._linkedParentDitIdx !== -1) {
+            return this.Form.getCtrl(this._linkedParentDitIdx);
+        }
+        else {
+            if (checkSubformFather && this.Form.isSubForm()) {
+                return this.Form.getSubFormCtrl();
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    SetCurrReadOnly(newVal) {
+        this._currReadOnly.set_Item(this.getDisplayLine(true), newVal);
+    }
+    GetCurrReadOnly() {
+        let line = super.isTableControl() ? 0 : this.getDisplayLine(true);
+        let currObj = this._currReadOnly.get_Item(line);
+        let curr;
+        if (currObj === null) {
+            curr = false;
+            this._currReadOnly.set_Item(line, curr);
+        }
+        else {
+            curr = currObj;
+        }
+        return curr;
+    }
+    isDataCtrl() {
+        return this._dataCtrl;
+    }
+    getDcRef() {
+        let line = this.getDcLineNum();
+        let obj = this._dcTableRefs.get_Item(this.getDcLineNum());
+        let dcId;
+        if (obj === null) {
+            dcId = -2;
+            this._dcTableRefs.set_Item(line, dcId);
+        }
+        else {
+            dcId = obj;
+        }
+        return dcId;
+    }
+    getDcLineNum() {
+        return this.IsRepeatable ? this.Form.DisplayLine : 0;
+    }
+    optionIsValid(option) {
+        let isValid = true;
+        if (this.DataType === StorageAttribute.NUMERIC && option.length > 0 && option.indexOf('0') === -1) {
+            let convertNum = new NUM_TYPE();
+            convertNum.num_4_a_std(option);
+            if (convertNum.num_is_zero()) {
+                isValid = false;
+            }
+        }
+        return isValid;
+    }
+    async getOrderedDispList(choiceDispList, line) {
+        let choiceLayerStr = "";
+        let dispArryList = new List();
+        let layerArryList = new List();
+        let layerProp = this.getProp(PropInterface.PROP_TYPE_VISIBLE_LAYERS_LIST);
+        if (layerProp !== null) {
+            choiceLayerStr = await layerProp.getValue();
+        }
+        if (choiceLayerStr === null || StrUtil.rtrim(choiceLayerStr).length === 0) {
+            choiceLayerStr = "";
+        }
+        if (choiceLayerStr.length > 0 && choiceDispList.length > 0) {
+            let layerList = choiceLayerStr.split(",");
+            let posCopyIndex = -1;
+            for (let index = 0; index < layerList.length; index = index + 1) {
+                let currLayerListVal = layerList[index].trim();
+                if (!(layerArryList.indexOf(currLayerListVal) !== -1)) {
+                    let refPosCopyIndex = new RefParam(posCopyIndex);
+                    let isNumber = NNumber.TryParse(currLayerListVal, refPosCopyIndex);
+                    posCopyIndex = refPosCopyIndex.value;
+                    if (isNumber && posCopyIndex > 0 && posCopyIndex <= choiceDispList.length) {
+                        dispArryList.push((choiceDispList[posCopyIndex - 1]).trim());
+                        layerArryList.push(currLayerListVal);
+                    }
+                }
+            }
+        }
+        let result;
+        if (dispArryList.length === 0) {
+            result = choiceDispList;
+            this._choiceLayerList.set_Item(line, new Array(0));
+        }
+        else {
+            result = new Array(dispArryList.length);
+            for (let _ai = 0; _ai < result.length; ++_ai)
+                result[_ai] = null;
+            result = dispArryList.ToArray();
+            this._choiceLayerList.set_Item(line, layerArryList.ToArray());
+        }
+        return result;
+    }
+    resetPrevVal() {
+        let line = this.getDisplayLine(true);
+        if (line < 0) {
+            line = 0;
+        }
+        this._prevValues.set_Item(line, null);
+        this.setPrevIsNull_ToNull();
+    }
+    setPrevIsNull_ToNull() {
+        this._prevIsNulls.set_Item(this.getDisplayLine(true), null);
+    }
+    expressionSetAsData() {
+        return this._valExpId > 0;
+    }
+    clearRange(line) {
+        this._orgChoiceDisps.set_Item(line, null);
+        this._choiceDisps.set_Item(line, null);
+        this._choiceLinks.set_Item(line, null);
+        this._choiceLayerList.set_Item(line, null);
+    }
+    haveToCheckParentValue() {
+        let ret = false;
+        if (this._linkedParentDitIdx !== -1) {
+            if (!this.isContainedInLinkedParent()) {
+                ret = true;
+            }
+            else {
+                if (this.Form.getCtrl(this._linkedParentDitIdx).isTabControl() || this.Form.getCtrl(this._linkedParentDitIdx).isGroup()) {
+                    ret = true;
+                }
+            }
+        }
+        else {
+            if (this.Form.isSubForm()) {
+                ret = true;
+            }
+        }
+        return ret;
+    }
+    isContainedInLinkedParent() {
+        return this._containerDitIdx !== -1 && this._containerDitIdx === this._linkedParentDitIdx;
+    }
+    static combineStringArrays(firstStrings, lastStrings) {
+        let result = new Array();
+        if (firstStrings !== null)
+            result = result.concat(firstStrings);
+        if (lastStrings !== null)
+            result = result.concat(lastStrings);
+        return result;
+    }
+    GetComputedBooleanProperty(propId, defaultRetVal, line) {
+        if (arguments.length === 2 && (propId === null || propId.constructor === Number) && (defaultRetVal === null || defaultRetVal.constructor === Boolean)) {
+            return this.GetComputedBooleanProperty_0(propId, defaultRetVal);
+        }
+        return this.GetComputedBooleanProperty_1(propId, defaultRetVal, line);
+    }
+    GetComputedBooleanProperty_0(propId, defaultRetVal) {
+        let result = defaultRetVal;
+        let prop = this.GetComputedProperty(propId);
+        if (prop !== null) {
+            result = prop.GetComputedValueBoolean();
+        }
+        return result;
+    }
+    GetComputedBooleanProperty_1(propId, defaultRetVal, line) {
+        let result = defaultRetVal;
+        if (this.isPropertyRepeatable(propId) && this.Form.DisplayLine !== line) {
+            let prop = this.GetComputedProperty(propId);
+            if (prop !== null) {
+                let val = prop.getPrevValue(line);
+                if (val !== null) {
+                    result = DisplayConvertor.toBoolean(val);
+                }
+            }
+        }
+        else {
+            result = this.GetComputedBooleanProperty(propId, defaultRetVal);
+        }
+        return result;
+    }
+    async checkPropWithLine(propId, defaultRetVal, line) {
+        let result = defaultRetVal;
+        if (this.isPropertyRepeatable(propId) && this.Form.DisplayLine !== line) {
+            let prop = this.getProp(propId);
+            if (prop !== null) {
+                let val = prop.getPrevValue(line);
+                if (val !== null) {
+                    result = DisplayConvertor.toBoolean(val);
+                }
+            }
+        }
+        else {
+            result = await this.checkProp(propId, defaultRetVal);
+        }
+        return result;
+    }
+    async checkProp(propId, defaultRetVal) {
+        let result = defaultRetVal;
+        let prop = this.getProp(propId);
+        if (prop !== null) {
+            result = await prop.getValueBoolean();
+        }
+        return result;
+    }
+    isPropertyRepeatable(propId) {
+        let isRepeatable = this.IsRepeatable;
+        if (isRepeatable) {
+            return true;
+        }
+        else {
+            return super.isTableControl() && Property.isRepeatableInTable();
+        }
+    }
+    async SetAndRefreshDisplayValue(mgVal, isNull) {
+        let dcRangeIsEmpty = true;
+        if (mgVal === null) {
+            this.Value = "";
+            if (!isNull)
+                mgVal = FieldDef.getMagicDefaultValue(this.DataType);
+        }
+        else {
+            if (super.isChoiceControl()) {
+                let line = this.getDisplayLine(true);
+                if (line < 0) {
+                    line = 0;
+                }
+                let layers = this.getLayerFromLinkIdx(await this.getIndexOfChoice(mgVal, line, isNull));
+                if (layers[0] < 0 && super.isTabControl()) {
+                    layers[0] = 0;
+                    mgVal = await this.getLinkValue(layers[0].toString(), line);
+                    isNull = false;
+                    if (this._field !== null && mgVal !== null) {
+                        await this._field.getTask().UpdateFieldValueAndStartRecompute(this._field, mgVal, isNull);
+                    }
+                }
+                this.Value = Misc.GetCommaSeperatedString(layers);
+                dcRangeIsEmpty = false;
+            }
+        }
+        if (dcRangeIsEmpty) {
+            if (!super.isCheckBox() && (this._field === null || !isNull || !this._field.hasNullDisplayValue())) {
+                try {
+                    if ((super.isImageControl() && this.DataType === StorageAttribute.BLOB) || super.IsImageButton()) {
+                        this.Value = mgVal;
+                    }
+                    else {
+                        if ((this._field === null && isNull) && (this.DataType === StorageAttribute.NUMERIC || this.DataType === StorageAttribute.DATE || this.DataType === StorageAttribute.TIME || this.DataType === StorageAttribute.BOOLEAN)) {
+                            this.Value = mgVal;
+                        }
+                        else {
+                            let inControl = this.InControl;
+                            this.Value = DisplayConvertor.Instance.mg2disp(mgVal, this._range, this._pic, true, super.isSelectionCtrl(), this.getForm().getTask().getCompIdx(), inControl);
+                        }
+                    }
+                    if (typeof this.Value === 'string' && (!this._pic.isAttrNumeric() || this._pic.isLeft())) {
+                        this.rtrimValue();
+                    }
+                }
+                catch (innerException) {
+                    if (innerException instanceof ApplicationException) {
+                        Events.WriteExceptionToLog(new ApplicationException(NString.Format("Control: '{0}', mgval: {1}", this.Name, mgVal), innerException));
+                        this.Value = "";
+                        mgVal = FieldDef.getMagicDefaultValue(this.DataType);
+                    }
+                    else
+                        throw innerException;
+                }
+            }
+            else {
+                if (this.isCheckBox())
+                    this.Value = DisplayConvertor.toBoolean(mgVal);
+                else
+                    this.Value = mgVal;
+            }
+        }
+        if ((super.isImageControl() && this.DataType !== StorageAttribute.BLOB) || super.IsImageButton()) {
+            mgVal = Events.TranslateLogicalName(mgVal);
+        }
+        this.IsNull = isNull;
+        await this.RefreshDisplayValue(mgVal);
+    }
+    UpdateModifiedByUser(newValue) {
+        if (!(super.isButton() || super.isImageControl())) {
+            let ctrlCurrIsNull = this.IsNull;
+            let valChanged = (this.isDifferentValue(newValue, false, false));
+            if (!valChanged) {
+                if (this.CanGetNullFromControlValue()) {
+                    valChanged = (ctrlCurrIsNull !== this.isNullValue(newValue));
+                }
+            }
+            if (valChanged || this.KeyStrokeOn) {
+                this.ModifiedByUser = true;
+            }
+        }
+    }
+    rtrimValue() {
+        if ((super.isImageControl() && this.DataType === StorageAttribute.BLOB) || super.IsImageButton()) {
+            this.Value = NString.TrimEnd(this.Value);
+        }
+        else {
+            let minimumValueLength = this.getMinimumValueLength();
+            if (this.Value.length > minimumValueLength) {
+                let str = this.Value.substr(minimumValueLength);
+                this.Value = this.Value.substr(0, minimumValueLength);
+                this.Value = this.Value + StrUtil.rtrimWithNull(str, true);
+            }
+            if (super.isTextControl() && this.DataType === StorageAttribute.NUMERIC) {
+                this.Value = NString.TrimEnd(this.Value);
+            }
+        }
+    }
+    getMinimumValueLength() {
+        let minLength = this._pic.getMaskLength();
+        while (minLength > 0 && !this._pic.picIsMask(minLength - 1)) {
+            minLength = minLength - 1;
+        }
+        return minLength;
+    }
+    isNullValue(str) {
+        let retIsNullControl = false;
+        if (this.CanGetNullFromControlValue() && str === "") {
+            retIsNullControl = true;
+        }
+        return retIsNullControl;
+    }
+    CanGetNullFromControlValue() {
+        return false;
+    }
+    isChoiceNull(idx) {
+        let result;
+        if (idx >= 0) {
+            let dcVals = this.getDcVals();
+            return dcVals.isNull(idx);
+        }
+        else {
+            return result;
+        }
+    }
+    async ComputeAndRefreshDisplayValue(forceRefresh) {
+        if (forceRefresh) {
+            this.resetPrevVal();
+        }
+        if (this._valExpId > 0) {
+            let wasEvaluated;
+            let refWasEvaluated = new RefParam(wasEvaluated);
+            let retExp = await this.EvaluateExpression(this._valExpId, this.DataType, this._pic.getSize(), true, StorageAttribute.SKIP, false, refWasEvaluated);
+            wasEvaluated = refWasEvaluated.value;
+            if (wasEvaluated) {
+                await this.SetAndRefreshDisplayValue(retExp, retExp === null);
+            }
+        }
+        else {
+            if (this._field !== null) {
+                let value = NString.Empty;
+                let isNull = false;
+                let refValue = new RefParam(value);
+                let refIsNull = new RefParam(isNull);
+                this._field.getTask().getFieldDisplayValue(this._field, refValue, refIsNull);
+                value = refValue.value;
+                isNull = refIsNull.value;
+                await this.SetAndRefreshDisplayValue(value, isNull);
+            }
+            else {
+                if (!super.isTableControl() && !super.isColumnControl()) {
+                    await this.RefreshDisplayValue(this.Value);
+                }
+            }
+        }
+    }
+    ShouldRefreshOnControlEnter() {
+        return this.Type === MgControlType.CTRL_TYPE_TEXT && this.getField() !== null && (this.getField().getType() === StorageAttribute.DATE ||
+            this.getField().getType() === StorageAttribute.TIME || this.getField().getType() === StorageAttribute.NUMERIC);
+    }
+    async RefreshDisplayValue(mgVal) {
+        let line = this.getDisplayLine(true);
+        let valueChanged = true;
+        let saveValueChanged = valueChanged;
+        if (line < 0) {
+            line = 0;
+        }
+        try {
+            let prevValue = this._prevValues.get_Item(line);
+            let prevNull = this.getPrevIsNull();
+            if (StorageAttributeCheck.IsTypeAlphaOrUnicode(this.DataType)) {
+                if (StrUtil.rtrim(mgVal) === StrUtil.rtrim(prevValue) ||
+                    (mgVal !== null && StrUtil.rtrim(mgVal) === StrUtil.rtrim(prevValue))) {
+                    valueChanged = false;
+                }
+                if (prevNull !== this.IsNull) {
+                    valueChanged = true;
+                }
+            }
+            else {
+                ;
+                if (mgVal === prevValue || (mgVal !== null && mgVal === prevValue))
+                    valueChanged = false;
+                if (prevNull !== this.IsNull)
+                    valueChanged = true;
+            }
+            this._prevValues.set_Item(line, mgVal);
+            this.setPrevIsNull(this.IsNull);
+            switch (this.Type) {
+                case MgControlType.CTRL_TYPE_TABLE:
+                case MgControlType.CTRL_TYPE_COLUMN:
+                case MgControlType.CTRL_TYPE_LABEL:
+                case MgControlType.CTRL_TYPE_SUBFORM:
+                case MgControlType.CTRL_TYPE_GROUP:
+                case MgControlType.CTRL_TYPE_STATUS_BAR:
+                case MgControlType.CTRL_TYPE_FRAME_SET:
+                case MgControlType.CTRL_TYPE_CONTAINER:
+                case MgControlType.CTRL_TYPE_FRAME_FORM:
+                case MgControlType.CTRL_TYPE_SB_LABEL:
+                case MgControlType.CTRL_TYPE_LINE:
+                    return;
+                case MgControlType.CTRL_TYPE_BROWSER:
+                    if (valueChanged && this.Value != null)
+                        this.setUrl();
+                    return;
+                case MgControlType.CTRL_TYPE_IMAGE:
+                case MgControlType.CTRL_TYPE_SB_IMAGE:
+                    if (valueChanged && this.Value != null)
+                        this.setImage();
+                    return;
+                case MgControlType.CTRL_TYPE_CHECKBOX:
+                    if (valueChanged || this.forceRefresh)
+                        this.setCheckBoxValue(line, mgVal);
+                    return;
+                case MgControlType.CTRL_TYPE_TAB:
+                case MgControlType.CTRL_TYPE_COMBO:
+                case MgControlType.CTRL_TYPE_LIST:
+                    saveValueChanged = valueChanged;
+                    valueChanged = await this.refreshAndSetItemListByDataSource(line, valueChanged);
+                    if (valueChanged) {
+                        let prevDisplayValue = null;
+                        if (saveValueChanged === valueChanged) {
+                            if (prevValue !== null) {
+                                prevDisplayValue = this.getLayerFromLinkIdx(await this.getIndexOfChoice(prevValue, line, prevNull));
+                                for (let i = 0; i < prevDisplayValue.length; i = i + 1) {
+                                    if (prevDisplayValue[i] === GuiConstants.DEFAULT_VALUE_INT) {
+                                        prevDisplayValue[i] = GuiConstants.DEFAULT_LIST_VALUE;
+                                    }
+                                }
+                            }
+                        }
+                        let indice = Misc.GetIntArray(this.Value);
+                        if (this.isTabControl()) {
+                            let currentLayer = this.getCurrentLinkIdx();
+                            Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.SelectedValue, indice[0].toString());
+                            Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.SelectedLayer, currentLayer.toString());
+                        }
+                        if (this.IsMultipleSelectionListBox()) {
+                            Commands.addValueWithLine(CommandType.SET_VALUE, this, line, indice);
+                        }
+                        else
+                            Commands.addValueWithLine(CommandType.SET_VALUE, this, line, +this.Value);
+                    }
+                    break;
+                case MgControlType.CTRL_TYPE_BUTTON:
+                case MgControlType.CTRL_TYPE_TEXT:
+                    if (this.HasAutocomplete())
+                        await this.refreshAndSetItemListByDataSource(line, valueChanged);
+                    if (valueChanged) {
+                        if (this.IsImageButton()) {
+                            this.setImageWithFileName(this.Value);
+                        }
+                        else
+                            this.setText();
+                    }
+                    else
+                        return;
+                    break;
+                case MgControlType.CTRL_TYPE_RADIO:
+                    valueChanged = await this.refreshAndSetItemListByDataSource(line, valueChanged);
+                    if (!valueChanged)
+                        return;
+                    this.setRadioChecked(this.Value);
+                    break;
+                default:
+                    Events.WriteExceptionToLog(NString.Format("in Control.RefreshDisplayValue() unknown type: {0}", this.Type));
+                    return;
+            }
+            if (super.isChoiceControl() && valueChanged)
+                await this.updatePropertyLogicNesting(PropInterface.PROP_TYPE_VISIBLE, CommandType.PROP_SET_VISIBLE, await this.checkProp(PropInterface.PROP_TYPE_VISIBLE, true), false);
+        }
+        catch (ex_360) {
+            if (ex_360 instanceof Exception) {
+                Events.WriteExceptionToLog(NString.Format("in Control.RefreshDisplayValue() for control: {0}", this.Name));
+            }
+            else
+                throw ex_360;
+        }
+    }
+    async RefreshDisplay(onlyRepeatableProps) {
+        if (isNullOrUndefined(onlyRepeatableProps))
+            onlyRepeatableProps = false;
+        await this.RefreshDisplay_1(onlyRepeatableProps);
+    }
+    async RefreshDisplay_1(onlyRepeatableProps) {
+        if (!(super.isSubform() && this.GetSubformMgForm() !== null && this.GetSubformMgForm().inRefreshDisplay())) {
+            await this.refreshProperties(onlyRepeatableProps);
+            if (this.ShouldComputeAndRefreshOnClosedForm()) {
+                await this.ComputeAndRefreshDisplayValue(false);
+            }
+            let isParkableCtrl = !(await this.isParkable(false)) || !await this.isModifiable();
+            if (this.GetCurrReadOnly() !== isParkableCtrl) {
+                this.SetCurrReadOnly(isParkableCtrl);
+                await Manager.SetReadOnlyControl(this, isParkableCtrl);
+            }
+            let mustInputProperty = this.GetComputedProperty(PropInterface.PROP_TYPE_MUST_INPUT);
+            if (mustInputProperty != null && mustInputProperty.isExpression()) {
+                let prevMustInput = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MUST_INPUT, false);
+                if (prevMustInput !== await this.checkProp(PropInterface.PROP_TYPE_MUST_INPUT, false))
+                    Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.MustInput, !prevMustInput);
+            }
+            if (!this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_TAB_IN, true))
+                Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.TabIndex, -1);
+        }
+    }
+    ShouldComputeAndRefreshOnClosedForm() {
+        return true;
+    }
+    async refreshProperties(onlyRepeatableProps) {
+        if (this._field !== null && this.DataType !== StorageAttribute.NONE && this._firstRefreshProperties)
+            Commands.addWithNumber(CommandType.SET_ATTRIBUTE, this, this.DataType.charCodeAt(0));
+        if (this._propTab !== null) {
+            try {
+                if (this._firstRefreshProperties) {
+                    this.createDefaultProps();
+                    await this.ZoomButtonInitialization();
+                }
+                if (!(await this._propTab.RefreshDisplay(false, onlyRepeatableProps))) {
+                    Events.WriteExceptionToLog(NString.Format("Control '{0}': Not all properties could be set", this.getName()));
+                }
+                if (this._firstRefreshProperties) {
+                    if (!onlyRepeatableProps) {
+                        this._firstRefreshProperties = false;
+                    }
+                }
+            }
+            catch (ex) {
+                if (ex instanceof Exception) {
+                    let msg = new StringBuilder(NString.Format("Control '{0}': {1}", this.getName(), ex.Message));
+                    Events.WriteExceptionToLog(msg.ToString());
+                }
+                else
+                    throw ex;
+            }
+        }
+    }
+    async refreshTabForLayerList(line) {
+        let currentLinkValue = null;
+        if (this.getForm().Opened) {
+            let indice = this.getCurrentIndexOfChoice();
+            let currentLayer = indice[0];
+            currentLinkValue = await this.getLinkValue(currentLayer.toString(), line);
+        }
+        await this.refreshAndSetItemsList(line, false);
+        if (this.getForm().Opened) {
+            await this.SetAndRefreshDisplayValue(currentLinkValue, this.IsNull);
+        }
+    }
+    async refreshAndSetItemsListForRadioButton(line, execComputeChoice) {
+        let displayList = await this.refreshDispRange(execComputeChoice);
+        let options = displayList.map((displayValue, counter) => {
+            let index = counter.toString();
+            return { index, displayValue };
+        });
+        Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.ItemsList, options);
+    }
+    async refreshAndSetItemsList(line, execComputeChoice) {
+        if (execComputeChoice) {
+            this.clearRange(line);
+        }
+        let optionsStrings = await this.refreshDispRange(execComputeChoice);
+        if (super.isSelectionCtrl() || super.isTabControl() || this.HasAutocomplete()) {
+            let options = optionsStrings.map((displayValue, index) => {
+                return { index, displayValue };
+            });
+            Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.ItemsList, options);
+        }
+        else {
+            if (super.isRadio()) {
+                await this.refreshAndSetItemsListForRadioButton(line, execComputeChoice);
+            }
+        }
+    }
+    async refreshDispRange(execComputeChoice) {
+        let selectCmd = new Array(0);
+        let line = this.getDisplayLine(true);
+        if (line < 0) {
+            line = 0;
+        }
+        if (this.SupportsDataSource()) {
+            let dataView = this.getForm().getTask().DataView;
+            let dcv = dataView.getDcValues(this._dcValId);
+            let dispVals = await this.getDispVals(line, execComputeChoice);
+            if (this._hasValidItmAndDispVal) {
+                selectCmd = MgControlBase.combineStringArrays(dispVals, dcv.getDispVals());
+            }
+        }
+        else {
+            selectCmd = await this.getDispVals(line, execComputeChoice);
+        }
+        this._rangeChanged = true;
+        return await this.getOrderedDispList(selectCmd, line);
+    }
+    async refreshItmRange(execComputeChoice) {
+        Debug.Assert(this.SupportsDataSource());
+        let orderedItmList = new Array(0);
+        let line = this.getDisplayLine(false);
+        if (line < 0) {
+            line = 0;
+        }
+        if (execComputeChoice) {
+            await this.computeChoice(line);
+        }
+        let linkVals = this._choiceLinks.get_Item(line);
+        let dataView = this.getForm().getTask().DataView;
+        let dcv = dataView.getDcValues(this._dcValId);
+        if (this._hasValidItmAndDispVal) {
+            orderedItmList = MgControlBase.combineStringArrays(linkVals, dcv.GetLinkVals());
+        }
+        return await this.getOrderedDispList(orderedItmList, line);
+    }
+    async GetItemsRange() {
+        return await this.refreshItmRange(false);
+    }
+    async GetDisplayRange() {
+        return await this.refreshDispRange(false);
+    }
+    createDefaultProps() {
+        this.getProp(PropInterface.PROP_TYPE_VISIBLE);
+        this.getProp(PropInterface.PROP_TYPE_ENABLED);
+        if (super.isTableControl()) {
+            this.getProp(PropInterface.PROP_TYPE_SCROLL_BAR);
+        }
+    }
+    setLinkedParentIdx(linkedParentDitIdx) {
+        this._linkedParentDitIdx = linkedParentDitIdx;
+    }
+    buildPicture(oldVal, val) {
+        if (super.isTableControl() || super.isColumnControl())
+            return null;
+        if (this._picExpExists) {
+            this._vd = null;
+        }
+        if (this._vd === null) {
+            this._vd = new ValidationDetails(oldVal, val, this._range, this._pic, this);
+        }
+        else {
+            this._vd.setValue(val);
+            this._vd.setOldValue(oldVal);
+        }
+        return this._vd;
+    }
+    isDifferentValue(newValue, isNull, checkNullValue) {
+        let ctrlCurrValue = this.Value;
+        let valChanged = false;
+        if (newValue instanceof Date) {
+            if (this.DataType === StorageAttribute.DATE)
+                valChanged = !this.CompareDate(newValue, ctrlCurrValue);
+            else
+                valChanged = !this.CompareTime(newValue, ctrlCurrValue);
+        }
+        if (typeof newValue === 'boolean' || typeof newValue === 'number') {
+            if (this.isSelectionCtrl() && typeof ctrlCurrValue === 'string') {
+                let newValuestr = newValue.toString();
+                valChanged = (newValuestr !== ctrlCurrValue);
+            }
+            else {
+                valChanged = (newValue !== ctrlCurrValue);
+            }
+        }
+        else {
+            if (this.isSelectionCtrl() && typeof ctrlCurrValue === 'string' && Array.isArray(newValue)) {
+                let newValueStr = newValue.join(',').toString();
+                valChanged = !(StrUtil.rtrim(newValueStr) === StrUtil.rtrim(ctrlCurrValue));
+            }
+            else {
+                let ctrlCurrIsNull = this.IsNull;
+                valChanged = !(StrUtil.rtrim(newValue) === StrUtil.rtrim(ctrlCurrValue));
+                if (!valChanged && checkNullValue) {
+                    valChanged = (isNull !== ctrlCurrIsNull);
+                }
+            }
+        }
+        return valChanged;
+    }
+    CompareDate(d1, d2) {
+        let retval;
+        if (d1 === null && d2 === null)
+            retval = true;
+        else if ((d1 === null && d2 !== null) || (d1 !== null && d2 === null))
+            retval = false;
+        else if (d1.getFullYear() === d2.getFullYear()
+            && d1.getDate() === d2.getDate()
+            && d1.getMonth() === d2.getMonth())
+            retval = true;
+        return retval;
+    }
+    CompareTime(d1, d2) {
+        let retval;
+        if (d1 === null && d2 === null)
+            retval = true;
+        else if ((d1 === null && d2 !== null) || (d1 !== null && d2 === null))
+            retval = false;
+        else if (d1.getHours() === d2.getHours()
+            && d1.getMinutes() === d2.getMinutes()
+            && d1.getSeconds() === d2.getSeconds())
+            retval = true;
+        return retval;
+    }
+    isColumnSortable() {
+        let isSortable = false;
+        if (this.Type === MgControlType.CTRL_TYPE_COLUMN && this._propTab.propExists(PropInterface.PROP_TYPE_SORT_COLUMN)) {
+            isSortable = this.GetComputedProperty(PropInterface.PROP_TYPE_SORT_COLUMN).GetComputedValueBoolean();
+        }
+        return isSortable;
+    }
+    getColumnChildControl() {
+        if (this.Type !== MgControlType.CTRL_TYPE_COLUMN)
+            return null;
+        let linkedControls = this._parentTable.getLinkedControls();
+        return linkedControls.find((control) => (control.getLayer() === this.getLayer() && control.Type !== MgControlType.CTRL_TYPE_COLUMN && !control.IsTableHeaderChild));
+    }
+    getControlNameForHandlerSearch() {
+        let childControl = this.getColumnChildControl();
+        let name;
+        if (childControl !== null) {
+            return childControl.Name;
+        }
+        else
+            return this.Name;
+    }
+    linkCtrl(ctrl) {
+        this._linkedControls.push(ctrl);
+    }
+    removeRefFromField() {
+        if (this._field !== null) {
+            this._field.RemoveControl(this);
+        }
+    }
+    getDitIdx() {
+        return this._ditIdx;
+    }
+    setDcValId(dcValId) {
+        this._dcValId = dcValId;
+    }
+    SetKeyboardLanguage() {
+        Commands.beginInvoke();
+    }
+    Init() {
+    }
+    async IsParkable() {
+        return await this.isParkable(true);
+    }
+    HasExpOrParentTaskField() {
+        let task = this.getForm().getTask();
+        return (this.getField() === null || this.getField().getTask() !== task);
+    }
+    async isParkable(checkEnabledAndVisible) {
+        let result;
+        result = !super.isTableControl() && !super.isColumnControl();
+        let task = this.getForm().getTask();
+        if (result) {
+            result = task.IsInteractive;
+        }
+        if (result && task.DataView.isEmptyDataview() && this._field !== null && this._field.PartOfDataview) {
+            result = false;
+        }
+        if (result) {
+            if (!super.isSubform()) {
+                result = ((this._field !== null && this._field.getTask() === task) || this.isButton() || super.isBrowserControl());
+            }
+            if (result && checkEnabledAndVisible) {
+                result = (this.isEnabled() && this.isVisible());
+            }
+            if ((result && this._parentTable !== null) && checkEnabledAndVisible) {
+                result = (this._parentTable.GetComputedBooleanProperty(PropInterface.PROP_TYPE_ENABLED, true) && this._parentTable.GetComputedBooleanProperty(PropInterface.PROP_TYPE_VISIBLE, true));
+            }
+        }
+        return result;
+    }
+    RaiseControlHitOnLeftClickOfMouseDown() {
+        let raiseCtrlHit = false;
+        if (!super.IsHyperTextButton() && !super.isRadio() && !super.isTabControl()) {
+            raiseCtrlHit = true;
+        }
+        return raiseCtrlHit;
+    }
+    GetVarIndex() {
+        return 0;
+    }
+    RaiseControlHitOnMouseDown(leftClickWasPressed) {
+        let raiseCtrlHit = false;
+        if (leftClickWasPressed) {
+            if (this.RaiseControlHitOnLeftClickOfMouseDown()) {
+                raiseCtrlHit = true;
+            }
+        }
+        return raiseCtrlHit;
+    }
+    OnSubformClick() {
+        Manager.EventsManager.addGuiTriggeredEventWithTaskAndCode(this.getForm().getTask(), InternalInterface.MG_ACT_HIT);
+    }
+    GetSubformMgForm() {
+        return null;
+    }
+    PropertyExists(id) {
+        return this._propTab.propExists(id);
+    }
+    toString() {
+        return "{" + this.constructor.name + ": " + MgControlType[this.Type] + "}";
+    }
+    isDateZero(val) {
+        let zeroDate = false;
+        if (val instanceof Date) {
+            if (val.getMonth() === 0 && val.getFullYear() === 0 && val.getDay() === 0)
+                zeroDate = true;
+        }
+        return zeroDate;
+    }
+    IsDefaultRouterOutlet() {
+        return (this.Type === MgControlType.CTRL_TYPE_SUBFORM && this.GetComputedBooleanProperty_0(PropInterface.PROP_TYPE_DEFAULT_OUTLET, false));
+    }
+    IsRouterOutlet() {
+        return (this.Type === MgControlType.CTRL_TYPE_SUBFORM && this.GetComputedBooleanProperty_0(PropInterface.PROP_TYPE_IS_ROUTER_OUTLET, false));
+    }
+    async ZoomButtonInitialization() {
+        if (this.isTextControl() && this.checkIfExistProp(PropInterface.PROP_TYPE_CONNECTED_ZOOM_CONTROL)) {
+            let connectedButton = this.Form.CtrlTab.GetControlByIsn((await (await this.getProp(PropInterface.PROP_TYPE_CONNECTED_ZOOM_CONTROL)).getValueInt()));
+            let imageFileName = null;
+            if (connectedButton.IsImageButton() && connectedButton.PropertyExists(PropInterface.PROP_TYPE_IMAGE_FILENAME)) {
+                imageFileName = await (await connectedButton.getProp(PropInterface.PROP_TYPE_IMAGE_FILENAME)).getValue();
+                if (!Misc.IsWebUrl(imageFileName))
+                    imageFileName = "./assets/images/" + imageFileName;
+                Commands.addOperationWithLine(CommandType.SET_STYLE, this, 0, MagicProperties.ImageFile, imageFileName);
+            }
+            this.ConnectedControl = connectedButton;
+            connectedButton.ConnectedControl = this;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MgControlBase.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/gui/MgControlBase.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ApplicationException,\r\n  Debug,\r\n  Exception,\r\n  List,\r\n  NNumber,\r\n  NString,\r\n  RefParam,\r\n  StringBuilder,\r\n  isNullOrUndefined\r\n} from '@magic-xpa/mscorelib';\r\nimport {GuiMgControl} from '../../gui/GuiMgControl';\r\nimport {PropParentInterface} from '../../gui/PropParentInterface';\r\nimport {GuiFieldBase} from '../data/GuiFieldBase';\r\nimport {\r\n  ChoiceUtils,\r\n  Constants,\r\n  InternalInterface,\r\n  MagicProperties,\r\n  MgControlType,\r\n  Misc,\r\n  SEQ_2_STR,\r\n  StorageAttribute,\r\n  StorageAttributeCheck,\r\n  StrUtil,\r\n  UtilStrByteMode,\r\n  XMLConstants,\r\n  XmlParser\r\n} from '@magic-xpa/utils';\r\nimport {MgFormBase} from './MgFormBase';\r\nimport {PIC} from './PIC';\r\nimport {PropTable} from './PropTable';\r\nimport {ValidationDetails} from './ValidationDetails';\r\nimport {FieldDef} from '../data/FieldDef';\r\nimport {Property} from './Property';\r\nimport {GuiTaskBase} from '../tasks/GuiTaskBase';\r\nimport {Manager} from '../../Manager';\r\nimport {CommandType, HtmlProperties} from '../../GuiEnums';\r\nimport {Commands} from '../../Commands';\r\nimport {NUM_TYPE} from '../data/NUM_TYPE';\r\nimport {PropInterface} from './PropInterface';\r\nimport {Events} from '../../Events';\r\nimport {DcValues, EMPTY_DCREF} from '../data/DcValues';\r\nimport {GuiDataViewBase} from '../data/GuiDataViewBase';\r\nimport {DisplayConvertor} from './DisplayConvertor';\r\nimport {BlobType} from '../data/BlobType';\r\nimport {VectorType} from '../data/VectorType';\r\nimport {ObjectReference} from '../../util/ObjectReference';\r\nimport {GuiConstants} from '../../GuiConstants';\r\nimport {GuiControlPropertyAdapter} from './GuiControlPropertyAdapter';\r\nimport {FocusManager} from '../../FocusManager';\r\n\r\n\r\n/// <summary>\r\n///   data for <control> ...</control> tag\r\n/// </summary>\r\nexport abstract class MgControlBase extends GuiControlPropertyAdapter implements PropParentInterface {\r\n\r\n  // fixed defect #:81498, while RT is set default value we need to refresh the control\r\n  // to the value will set to the control\r\n\r\n  _ditIdx: number = 0;\r\n  private _linkedControls: List<MgControlBase> = null; // array of controls that are linked to this control\r\n  _field: GuiFieldBase = null; // reference to the field of the control\r\n  private _picStr: string = null;\r\n  _choiceDisps: List<string[]> = null; // for SELECT controls, holds the\r\n  _choiceLayerList: List<string[]> = null; // the order on which tabs to be displayed\r\n  _choiceLinks: List<string[]> = null; // for SELECT controls, holds the\r\n  _choiceNums: List<NUM_TYPE[]> = null;  // for SELECT controls, with numeric\r\n  private _containerDitIdx: number = -1;\r\n  _currReadOnly: List<boolean> = null; // a history array for readonly param\r\n  private _dataCtrl: boolean = false; // The data control flag states that this\r\n  _dcTableRefs: List<number> = null; // references to dcVals for each line of a control is a data control\r\n  private _firstRefreshProperties: boolean = true;\r\n  private _form: MgFormBase = null;\r\n  private _hasValidItmAndDispVal: boolean = false;\r\n  private _id: number = -1; // ControlIsn of the control (for subform)\r\n  private _controlIsn: number = -1; // for current isn\r\n\r\n  private _linkedParentDitIdx: number = -1; // not trigger any event handler, while parking in this control\r\n  _orgChoiceDisps: List<string[]> = null; // for TAB Control save the org option (with the &)\r\n  _parentTable: MgControlBase = null; // reference to parent Magic Table for\r\n  _pic: PIC = null;\r\n  private _picExpExists: boolean = false;\r\n  _prevIsNulls: List<boolean> = null; // for NULL\r\n  private _prevPicExpResult: string = null;\r\n  _prevValues: List<string> = null; // references to previous values of the\r\n  _propTab: PropTable = null;\r\n  private _range: string = null;\r\n  private _rangeChanged: boolean = false; // for SELECT controls, true if their range\r\n  private _rtfVal: string = NString.Empty; // field to store the rtf text of rich edit control\r\n  _valExpId: number = 0; // reference to the value expression\r\n  private _vd: ValidationDetails = null;\r\n  private _dcValId: number = -2;\r\n  parent: number = 0;\r\n  veeIndx: number = 0;\r\n  DNObjectReferenceField: FieldDef = null;\r\n  SourceTableReference: ObjectReference = null;\r\n  ClipBoardDataExists: boolean = false;\r\n  DataType: StorageAttribute = StorageAttribute.NONE;\r\n  KeyStrokeOn: boolean = false; // true if the user pressed a key\r\n  ModifiedByUser: boolean = false;\r\n  Value: any = null;\r\n  IsNull: boolean = false;\r\n  forceRefresh : boolean = false;\r\n  private _isModal : boolean; //applicable for subform, if subform is Modal\r\n\r\n  protected set Form(value: MgFormBase) {\r\n    this._form = value;\r\n    this.GuiMgForm = value;\r\n  }\r\n\r\n  protected get Form(): MgFormBase {\r\n    return this._form;\r\n  }\r\n\r\n  get Id(): number {\r\n    return this._id;\r\n  }\r\n\r\n  get ControlIsn(): number {\r\n    return this._controlIsn;\r\n  }\r\n\r\n  RefreshOnVisible: boolean = false; // true, if the subform must be refreshed on become visible\r\n  InControl: boolean = false;\r\n  ValidateControl: boolean = false;\r\n  PromptHelp: string = null;\r\n\r\n  // the prompt help text assigned to control\r\n\r\n  constructor();\r\n  constructor(type: MgControlType, parentMgForm: MgFormBase, parentControl: number);\r\n  constructor(type?: MgControlType, parentMgForm?: MgFormBase, parentControl?: number) {\r\n    super();\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    this.constructor_1(type, parentMgForm, parentControl);\r\n  }\r\n\r\n  private constructor_0(): void {\r\n    this._linkedControls = new List<MgControlBase>();\r\n    this.DataType = StorageAttribute.NONE;\r\n  }\r\n\r\n  private constructor_1(type: MgControlType, parentMgForm: MgFormBase, parentControl: number): void {\r\n    this.constructor_0();\r\n    this.initReferences(parentMgForm);\r\n    this.Type = type;\r\n    this._containerDitIdx = parentControl;\r\n    this._linkedParentDitIdx = parentControl;\r\n    this._propTab = new PropTable(this);\r\n    this.createArrays(false);\r\n  }\r\n\r\n  get UniqueName(): string {\r\n    return this.Name;\r\n  }\r\n\r\n  get TaskTag(): string {\r\n    return this.Form.getTask().getTaskTag();\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"propId\"></param>\r\n  /// <returns></returns>\r\n  checkIfExistProp(propId: number): boolean {\r\n    let exist: boolean = false;\r\n    if (this._propTab !== null) {\r\n      let propById: Property = this._propTab.getPropById(propId);\r\n      exist = (propById !== null);\r\n    }\r\n    return exist;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a property of the control\r\n  /// </summary>\r\n  /// <param name = \"propId\">the Id of the property</param>\r\n  getProp(propId: number): Property {\r\n    let prop: Property = null;\r\n\r\n    if (this._propTab !== null) {\r\n      prop = this._propTab.getPropById(propId);\r\n      if (prop === null) {\r\n        prop = Property.getDefaultProp(propId, 'C', this);\r\n\r\n        // if the property doesn't exist then create a new property and give it the default value\r\n        // in addition add this property to the properties table\r\n        if (prop !== null) {\r\n          this._propTab.addProp(prop);\r\n        }\r\n      }\r\n    }\r\n    return prop;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the form of the control\r\n  /// </summary>\r\n  getForm(): MgFormBase {\r\n    return this.Form;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getCompIdx(): number {\r\n    return this.getForm().getTask().getCompIdx();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return true if this is first refresh\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  IsFirstRefreshOfProps(): boolean {\r\n    return this._firstRefreshProperties;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"expId\"></param>\r\n  /// <param name=\"resType\"></param>\r\n  /// <param name=\"length\"></param>\r\n  /// <param name=\"contentTypeUnicode\"></param>\r\n  /// <param name=\"resCellType\"></param>\r\n  /// <param name=\"alwaysEvaluate\"></param>\r\n  /// <param name=\"wasEvaluated\"></param>\r\n  /// <returns></returns>\r\n  async EvaluateExpression(expId: number, resType: StorageAttribute, length: number, contentTypeUnicode: boolean, resCellType: StorageAttribute, alwaysEvaluate: boolean, wasEvaluated: RefParam<boolean>): Promise<string> {\r\n    return await this.getForm().getTask().EvaluateExpression(expId, resType, length, contentTypeUnicode, resCellType, alwaysEvaluate, wasEvaluated);\r\n  }\r\n\r\n  GetExpressionStorage(expId: number): StorageAttribute {\r\n    return this.getForm().getTask().GetExpressionStorage(expId);\r\n  }\r\n\r\n  /// <summary>\r\n  /// get a property of the control that already was computed\r\n  /// This method does not create a property if it isn't exist.\r\n  /// May we need to create a property and use its default value.\r\n  /// In Phase 2 in RefreshProperties method we'll create and compute properties,\r\n  /// perhaps we need create all properties not only those that are different from default.\r\n  /// </summary>\r\n  /// <param name = \"propId\">the Id of the property</param>\r\n  GetComputedProperty(propId: number): Property {\r\n    let prop: Property = null;\r\n\r\n    if (this._propTab !== null)\r\n      prop = this._propTab.getPropById(propId);\r\n    return prop;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Initializing of inner reference to the task of the control\r\n  /// </summary>\r\n  /// <param name = \"taskRef\">reference to the task of the control</param>\r\n  private initReferences(mgForm: MgFormBase): void {\r\n    this.Form = mgForm;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   in the first time that we refresh the control need to create arrays\r\n  /// </summary>\r\n  /// <param name = \"forceCreateArrays\">create arrays in any case</param>\r\n  createArrays(forceCreateArrays: boolean): void {\r\n    if (this._firstRefreshProperties || forceCreateArrays) {\r\n\r\n      // for SELECT controls, always initialize DC table since we use it to merge choices from the\r\n      // prop list with choices from the DATA CONTROL.\r\n      if (this.SupportsDataSource()) {\r\n        this._dcTableRefs = new List();\r\n      }\r\n      this._prevValues = new List();\r\n\r\n      // The property PROP_SET_READ_ONLY is set only if it is different from its previous value. By default\r\n      // this property is false, so we do not set it.\r\n      // But for the phantom task if this property was true, and we exit the phantom and again enter into\r\n      // this phantom the property becomes false.\r\n      // So we need to save the previous _currReadOnly value for the phantom task.\r\n      if (!forceCreateArrays) {\r\n        this._currReadOnly = new List();\r\n      }\r\n      this._choiceDisps = new List();\r\n      this._orgChoiceDisps = new List();\r\n      this._choiceLinks = new List();\r\n      this._choiceNums = new List();\r\n      this._prevIsNulls = new List();\r\n      this._choiceLayerList = new List();\r\n      if (!this.IsRepeatable && !super.isTableControl()) {\r\n        this.updateArrays(1);\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Sets the focus on the control and refreshes prompt.\r\n  /// </summary>\r\n  /// <param name=\"ctrl\">Control to have focus</param>\r\n  /// <param name=\"line\">line number</param>\r\n  /// <param name=\"refreshPrompt\"></param>\r\n  /// <param name=\"activateForm\">whether to activate a form after setfocus or not</param>\r\n  async SetFocus(ctrl: MgControlBase, line: number, activateForm: boolean): Promise<void> {\r\n    await FocusManager.SetFocus(ctrl.getForm().getTask(), ctrl, line, activateForm);\r\n  }\r\n\r\n  InsertArrays(idx: number, count: number): void {\r\n    this._prevValues.InsertRange( new Array(count));\r\n    this._prevIsNulls.InsertRange( new Array(count));\r\n\r\n    this._currReadOnly.InsertRange(new Array(count));\r\n    this._choiceDisps.InsertRange(new Array(count));\r\n    this._orgChoiceDisps.InsertRange( new Array(count));\r\n    this._choiceLinks.InsertRange( new Array(count));\r\n    this._choiceLayerList.InsertRange( new Array(count));\r\n    this._choiceNums.InsertRange(new Array(count));\r\n    if (this.SupportsDataSource())\r\n      this._dcTableRefs.InsertRange(new Array(count));\r\n    this._propTab.InsertPrevValueArray( count);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   update array's size according to the newSize\r\n  /// </summary>\r\n  /// <param name = \"newSize\"></param>\r\n  updateArrays(newSize: number): void {\r\n    this._prevValues.SetSize(newSize);\r\n    this._prevIsNulls.SetSize(newSize);\r\n    this._currReadOnly.SetSize(newSize);\r\n    this._choiceDisps.SetSize(newSize);\r\n    this._orgChoiceDisps.SetSize(newSize);\r\n    this._choiceLinks.SetSize(newSize);\r\n    this._choiceLayerList.SetSize(newSize);\r\n    this._choiceNums.SetSize(newSize);\r\n    if (this.SupportsDataSource()) {\r\n      this._dcTableRefs.SetSize(newSize);\r\n    }\r\n    this._propTab.updatePrevValueArray(newSize);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"newSize\"></param>\r\n  updatePrevValArrays(newSize: number): void {\r\n    this._propTab.updatePrevValueArray(newSize);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   To parse input string and fill inner data\r\n  /// </summary>\r\n  /// <param name = \"taskRef\">to parent task</param>\r\n  /// <param name = \"ditidx\">number of the Control in Control Table</param>\r\n  fillData(mgForm: MgFormBase, ditIdx: number, parser: XmlParser): void {\r\n    if (this.Form === null) {\r\n      this.initReferences(mgForm);\r\n    }\r\n    this._ditIdx = ditIdx;\r\n    while (this.initInnerObjects(parser.getNextTag(), parser)) {\r\n    }\r\n\r\n    // If the datatype is BLOB, its picture would be blank. But after version #97\r\n    // of AppSerializer.cs (changed for #485722), blank picture is not serialized.\r\n    // So, we need to explicitly set it to blank here.\r\n    if (this.DataType === StorageAttribute.BLOB && this._picStr === null) {\r\n      this._picStr = \"\";\r\n    }\r\n    if (this._picStr !== null && typeof this.DataType !== \"undefined\") {\r\n      this.setPIC(this._picStr);\r\n    }\r\n    else {\r\n\r\n\r\n      switch (this.Type) {\r\n        case MgControlType.CTRL_TYPE_IMAGE:\r\n        case MgControlType.CTRL_TYPE_BROWSER:\r\n        case MgControlType.CTRL_TYPE_BUTTON:\r\n          if (this.DataType === StorageAttribute.NONE)\r\n            this.DataType = StorageAttribute.ALPHA;\r\n          break;\r\n        case MgControlType.CTRL_TYPE_TABLE:\r\n        case MgControlType.CTRL_TYPE_COLUMN:\r\n        case MgControlType.CTRL_TYPE_SUBFORM:\r\n        case MgControlType.CTRL_TYPE_GROUP:\r\n        case MgControlType.CTRL_TYPE_FRAME_SET:\r\n        case MgControlType.CTRL_TYPE_FRAME_FORM:\r\n        case MgControlType.CTRL_TYPE_CONTAINER:\r\n        case MgControlType.CTRL_TYPE_LINE:\r\n          break;\r\n        default:\r\n          Events.WriteExceptionToLog(NString.Format(\"in Control.fillData(): missing datatype or picture string for control: {0}\", this.Name));\r\n          break;\r\n      }\r\n    }\r\n\r\n    if (super.isTableControl()) {\r\n      this.Form.setTableCtrl(this);\r\n    }\r\n    this.createArrays(false);\r\n\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">name of tag, of object, which need be allocated</param>\r\n  /// <returns> boolean if next tag is inner tag</returns>\r\n  initInnerObjects(foundTagName: string, parser: XmlParser): boolean {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n\r\n    if (foundTagName === XMLConstants.MG_TAG_PROP) {\r\n      if (this._propTab === null)\r\n        this._propTab = new PropTable(this);\r\n\r\n      this._propTab.fillData(this, 'C', parser);\r\n\r\n    }\r\n    else if (foundTagName === XMLConstants.MG_TAG_CONTROL)\r\n      this.parseAttributes(parser);\r\n    else if (foundTagName === \"SourceTable\")\r\n      this.ParseSourceTable(parser);\r\n    else if (foundTagName === \"/\" + XMLConstants.MG_TAG_CONTROL) {\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n    }\r\n    else {\r\n      Events.WriteExceptionToLog(NString.Format(\"There is no such tag in Control. Insert else if to Control.initInnerObjects for {0}\", foundTagName));\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  private ParseSourceTable(parser: XmlParser): void {\r\n    parser.setCurrIndex2EndOfTag();\r\n    let objRefStr: string = parser.ReadToEndOfCurrentElement();\r\n    let sourceTableReference: ObjectReference = ObjectReference.FromXML(objRefStr.trim());\r\n\r\n    this.SourceTableReference = sourceTableReference;\r\n    // Skip the closing </prop> tag\r\n    parser.setCurrIndex2EndOfTag();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the attributes of the control from the XML\r\n  /// </summary>\r\n  private parseAttributes(parser: XmlParser): void {\r\n    let endContext: number = parser.getXMLdata().indexOf(\">\", parser.getCurrIndex());\r\n\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n\r\n      // last position of its tag\r\n      let tag: string = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(XMLConstants.MG_TAG_CONTROL) + XMLConstants.MG_TAG_CONTROL.length);\r\n\r\n      let tokens: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM)/*'\"'*/;\r\n\r\n      for (let i: number = 0; i < tokens.length; i = i + 2) {\r\n        let attribute: string = tokens.get_Item(i);\r\n        let valueStr: string = tokens.get_Item(i + 1);\r\n\r\n        this.SetAttribute(attribute, valueStr);\r\n      }\r\n      parser.setCurrIndex(endContext + 1); // to delete \">\" too\r\n    }\r\n    else {\r\n      Events.WriteExceptionToLog(\"in Control.FillName() out of string bounds\");\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// set the control attributes in parsing\r\n  /// </summary>\r\n  SetAttribute(attribute: string, valueStr: string): boolean {\r\n    let isTagProcessed: boolean = true;\r\n\r\n    switch (attribute) {\r\n      case XMLConstants.MG_ATTR_TYPE:\r\n        this.Type = valueStr[0] as MgControlType;\r\n        break;\r\n      case XMLConstants.MG_ATTR_DATA_CTRL:\r\n        this._dataCtrl = XmlParser.getBoolean(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_LINKED_PARENT:\r\n        this.setLinkedParentIdx(XmlParser.getInt(valueStr));\r\n        break;\r\n      case XMLConstants.MG_ATTR_CONTAINER:\r\n        this.setContainer(XmlParser.getInt(valueStr));\r\n        break;\r\n      case XMLConstants.MG_ATTR_ID:\r\n        this._id = XmlParser.getInt(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_CONTROL_ISN:\r\n        this._controlIsn = XmlParser.getInt(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_IS_MODAL:\r\n        this._isModal = XmlParser.getBoolean(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_CONTROL_Z_ORDER:\r\n        //TODO - not to serialize [Story 154547]\r\n        break;\r\n      case XMLConstants.MG_HOR_ALIGMENT_IS_INHERITED:\r\n        //TODO - not to serialize [Story 154547]\r\n        break;\r\n      default:\r\n        isTagProcessed = false;\r\n        break;\r\n    }\r\n\r\n    return isTagProcessed;\r\n\r\n  }\r\n\r\n  /// <summary> set the image on the control </summary>\r\n  /// <param name=\"fileName\"></param>\r\n  setImage(): void {\r\n    let newVal: string = this.Value;\r\n    if (newVal === null || this.IsNull) {\r\n      newVal = \"\";\r\n    }\r\n    if (this.DataType === StorageAttribute.BLOB) {\r\n      // TODO - check if should be supported .\r\n      // Commands.addAsync(CommandType.PROP_SET_IMAGE_DATA, this, this.getDisplayLine(false), BlobType.getBytes(newVal), prop.getValueInt());\r\n    }\r\n    else {\r\n      this.setImageWithFileName(newVal);\r\n    }\r\n  }\r\n\r\n  setImageWithFileName(fileName: string): void {\r\n    if (fileName === null) {\r\n      fileName = \"\";\r\n    }\r\n    fileName = Events.TranslateLogicalName(fileName);\r\n\r\n    if (!Misc.IsWebUrl(fileName))\r\n      fileName = \"./assets/images/\" + fileName;\r\n\r\n    if (this.IsImageButton()) {\r\n      Commands.addOperationWithLine(CommandType.SET_STYLE, this, 0, MagicProperties.ImageFile, fileName);\r\n    }\r\n    else {\r\n      Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.Image, fileName);\r\n      Commands.addValueWithLine(CommandType.SET_VALUE, this, this.getDisplayLine(false), fileName);\r\n    }\r\n\r\n    // We need to execute the layout only if the radio is not on table. for table, it is done\r\n    // from LgRadioContainer.setSpecificControlProperties().\r\n\r\n    // if (super.isRadio() && !this.IsRepeatable) {\r\n    //   Commands.addAsync(CommandType.EXECUTE_LAYOUT, this, this.getDisplayLine(false), false);\r\n    //}\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set container\r\n  /// </summary>\r\n  /// <param name = \"containerIdx\"></param>\r\n  private setContainer(containerIdx: number): void {\r\n    this._containerDitIdx = containerIdx;\r\n    let container: MgControlBase = null;\r\n    if (this._containerDitIdx !== -1) {\r\n      container = this.Form.getCtrl(this._containerDitIdx);\r\n    }\r\n\r\n    if (container !== null && container.Type === MgControlType.CTRL_TYPE_TABLE) {\r\n      this._parentTable = container;\r\n    }\r\n    this.IsRepeatable = (this._parentTable !== null && !super.isColumnControl());\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the name of the Control\r\n  /// </summary>\r\n  getName(): string {\r\n    // if (this.isRepeatable()) {\r\n    //   return super.getName(this.Form.DisplayLine);\r\n    // }\r\n\r\n    return this.Name;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getLinkedControls(): List<MgControlBase> {\r\n    return this._linkedControls;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   The control is repeatable control\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isRepeatable(): boolean {\r\n    return this.IsRepeatable;\r\n  }\r\n\r\n  IsModal() : boolean {\r\n    return this._isModal;\r\n  }\r\n\r\n  /// <summary> returns current display line of control</summary>\r\n  /// <param name=\"useLineForItems\">if true, use current line for tree</param>\r\n  getDisplayLine(useLineForItems: boolean): number {\r\n    let line: number = 0;\r\n    if (this.IsRepeatable || (useLineForItems && super.isTableControl())) {\r\n      line = this.Form.DisplayLine;\r\n    }\r\n    return line;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks visibility considering parent visibility\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isVisible(): boolean {\r\n    let result: boolean = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_VISIBLE, true);\r\n    if (result) {\r\n      result = this.isParentPropValue(PropInterface.PROP_TYPE_VISIBLE);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks enabled considering parent enabled\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isEnabled(): boolean {\r\n    return this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_ENABLED, true);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   returns true if the control is modifiable and the task mode is not query\r\n  /// </summary>\r\n  isModifiable(): boolean {\r\n\r\n    let modifiable: boolean = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MODIFIABLE, true);\r\n    let taskInQuery: boolean = this.getForm().getTask().getMode() === Constants.TASK_MODE_QUERY;\r\n    let modifyInQuery: boolean = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MODIFY_IN_QUERY, false);\r\n\r\n    let result: boolean = modifiable && (modifyInQuery || !taskInQuery);\r\n    if (result && this._field != null) {\r\n      result = (this._field.DbModifiable || this.getForm().getTask().getMode() === Constants.TASK_MODE_CREATE);\r\n    }\r\n    return result;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   returns the current dc values of this data control from the current record\r\n  /// </summary>\r\n  getDcVals(): DcValues {\r\n    let dataView: GuiDataViewBase = this.getForm().getTask().DataView;\r\n    let dcv: DcValues = null;\r\n    if (this._dcValId === EMPTY_DCREF) {\r\n      dcv = ((this.DataType === StorageAttribute.BLOB_VECTOR) ? dataView.getEmptyChoiceForVectors() : dataView.getEmptyChoice());\r\n    }\r\n    else {\r\n      if (this._dcValId > -1) {\r\n        dcv = dataView.getDcValues(this._dcValId);\r\n      }\r\n    }\r\n    return dcv;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the current isNull according to the control's current line number\r\n  /// </summary>\r\n  /// <returns> the PrevIsNull value</returns>\r\n  getPrevIsNull(): boolean {\r\n    let line: number = this.getDisplayLine(true);\r\n    let currObj: any = this._prevIsNulls.get_Item(line);\r\n    let curr: boolean;\r\n    if (currObj === null) {\r\n      curr = false;\r\n      this._prevIsNulls.set_Item(line, curr);\r\n    }\r\n    else {\r\n      curr = <boolean>currObj;\r\n    }\r\n    return curr;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the prevIsNull value of the prevIsNull array\r\n  ///   the newValue can be NULL or bool\r\n  /// </summary>\r\n  /// <param name = \"newValue\">the new value to be set</param>\r\n  setPrevIsNull(newValue: boolean): void {\r\n    this._prevIsNulls.set_Item(this.getDisplayLine(true), newValue);\r\n  }\r\n\r\n  /// <param name = \"picStr\"></param>\r\n  setPIC(picStr: string): void {\r\n\r\n    // for push button, translate the format.\r\n    if (super.isButton()) {\r\n      this._picStr = (super.IsImageButton() ? \"\" + XMLConstants.FILE_NAME_SIZE.toString() : Events.Translate(picStr));\r\n    }\r\n    else {\r\n      this._picStr = picStr;\r\n    }\r\n    this._pic = new PIC(this._picStr, this.DataType, this.getForm().getTask().getCompIdx());\r\n\r\n    if (this._dataCtrl && this._picStr.indexOf('H') > -1) {\r\n      this._pic.setHebrew();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the picture of the control\r\n  /// </summary>\r\n  /// <returns> PIC reference</returns>\r\n  getPIC(): PIC {\r\n    return this._pic;\r\n  }\r\n\r\n\r\n/// <returns> the parent of the control can be Table\\Tab\\Choice control\\Form</returns>\r\n  getParent(): any {\r\n    let retParent: any = this.Form;\r\n    if (this._containerDitIdx !== -1) {\r\n      retParent = this.Form.getCtrl(this._containerDitIdx);\r\n    }\r\n    else {\r\n      if (this.Form.isSubForm()) {\r\n        retParent = this.Form.getSubFormCtrl();\r\n      }\r\n    }\r\n    return retParent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the field attached to the control\r\n  /// </summary>\r\n  getField(): GuiFieldBase {\r\n    return this._field;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Set the field of the control by the field object\r\n  /// </summary>\r\n  /// <param name = \"field\"></param>\r\n  setField(fieldOrFieldStrID: any): void {\r\n    if (fieldOrFieldStrID === null || fieldOrFieldStrID instanceof GuiFieldBase) {\r\n      this.setField_0(fieldOrFieldStrID);\r\n      return;\r\n    }\r\n    this.setField_1(fieldOrFieldStrID);\r\n  }\r\n\r\n\r\n  private setField_0(field: GuiFieldBase): void {\r\n    this._field = field;\r\n    if (field !== null) {\r\n      this._field.SetControl(this);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Set the field of the control by a string field identifier\r\n  /// </summary>\r\n  /// <param name = \"valueStr\">the field identifier: \"parentId,fieldIdx\"/param>\r\n  private setField_1(fieldStrID: string): void {\r\n    let returnField: GuiFieldBase = this.getFieldByValueStr(fieldStrID);\r\n    if (returnField !== null) {\r\n      this._field = returnField;\r\n      this._field.SetControl(this);\r\n      return;\r\n    }\r\n    throw new ApplicationException(\"in Control.setField(): illegal field identifier: \" + fieldStrID);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the picture of the control\r\n  /// </summary>\r\n  /// <param name = \"format\">the format string</param>\r\n  /// <param name = \"expId\">an expression of the format</param>\r\n  setPicStr(format: string, expId: number): void {\r\n    this._picStr = format;\r\n    if (expId > 0) {\r\n      this._picExpExists = true;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the range of the control and clears the mask\r\n  /// </summary>\r\n  /// <param name = \"newRange\">is the new range</param>\r\n  setRange(newRange: string): void {\r\n    this._range = newRange;\r\n    this._vd = null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value expression\r\n  /// </summary>\r\n  /// <param name = \"expId\">a reference to the expression</param>\r\n  setValExp(expId: number): void {\r\n    this._valExpId = expId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get copy of validation details with new & old value without changing real validation details\r\n  /// </summary>\r\n  /// <param name = \"oldVal\">value of the control</param>\r\n  /// <param name = \"newVal\">value of the control</param>\r\n  buildCopyPicture(oldVal: string, newVal: string): ValidationDetails {\r\n    if (super.isTableControl() || super.isColumnControl()) {\r\n      return null;\r\n    }\r\n    else {\r\n      let copyVD: ValidationDetails = this.getCopyOfVD();\r\n      copyVD.setValue(newVal);\r\n      copyVD.setOldValue(oldVal);\r\n      return copyVD;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build copy of validation details, without influence to the real validation details\r\n  /// </summary>\r\n  private getCopyOfVD(): ValidationDetails {\r\n    let result: ValidationDetails;\r\n    if (this._vd === null) {\r\n      result = new ValidationDetails(this.Value, this.Value, this._range, this._pic, this);\r\n    }\r\n    else {\r\n      result = new ValidationDetails(this._vd);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get ranges\r\n  /// </summary>\r\n  getRanges(): string {\r\n    return this._range;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get ranged value for input value\r\n  /// </summary>\r\n  getRangedValue(newVal: any): string {\r\n\r\n    let vd: ValidationDetails;\r\n    vd = this.buildCopyPicture(this.Value, newVal);\r\n    vd.evaluate();\r\n\r\n    // the validation of the fields value was wrong\r\n    let val: any  = vd.getDispValue()\r\n    return (val.toString());\r\n  }\r\n\r\n  /// <summary>\r\n  ///   validate user input\r\n  /// </summary>\r\n  validate(newVal: any): string {\r\n\r\n    let vd: ValidationDetails;\r\n    let modified: boolean = this.ModifiedByUser;\r\n    this.ModifiedByUser = true;\r\n    vd = this.buildCopyPicture(this.Value, newVal);\r\n    vd.evaluate();\r\n    this.ModifiedByUser = modified;\r\n    // the validation of the fields value was wrong\r\n    if (vd.ValidationFailed)\r\n      return vd.ErrorMessage;\r\n    else\r\n      return null;\r\n  }\r\n\r\n\r\n  /// <param name = \"valueStr\"></param>\r\n  /// <returns></returns>\r\n  private getFieldByValueStr(valueStr: string): GuiFieldBase {\r\n\r\n    let refParent: RefParam<number> = new RefParam<number>(this.parent);\r\n    let refVeeIndx: RefParam<number> = new RefParam<number>(this.veeIndx);\r\n    let ret: GuiFieldBase = <GuiFieldBase>this.getForm().getTask().getFieldByValueStr(valueStr, refParent, refVeeIndx);\r\n    this.parent = refParent.value;\r\n    this.veeIndx = refVeeIndx.value;\r\n    return ret;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if has container\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  hasContainer(): boolean {\r\n    return this._containerDitIdx !== -1;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   gets layer of control\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getLayer(): number {\r\n    return this.Layer;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   computes the pic using the result of the format expression\r\n  /// </summary>\r\n  /// <param name = \"picExpResult\">the result of the format expression</param>\r\n  /// <returns> PIC reference </returns>\r\n  computePIC(picExpResult: string): PIC {\r\n    // for push button, translate the format.\r\n    let picResult: string = (picExpResult !== null && super.isButton()) ? Events.Translate(picExpResult) : picExpResult;\r\n\r\n    // construct a new picture only if the expression result is different than the previous result\r\n    if (this._prevPicExpResult === null || !(this._prevPicExpResult === picResult)) {\r\n      this._pic = new PIC(picResult, this.DataType, this.getForm().getTask().getCompIdx());\r\n      this._prevPicExpResult = picResult;\r\n    }\r\n    return this._pic;\r\n  }\r\n\r\n  /// <summary>\r\n  /// gets the index of the current choice in the choice control\r\n  /// </summary>\r\n  /// <returns>index of the current choice</returns>\r\n  getCurrentIndexOfChoice(): number[] {\r\n    let selectedIndice: number[] = [-1];\r\n\r\n    let val: string = this.Value;\r\n\r\n    if (!NString.IsNullOrEmpty(val)) {\r\n      let array2: string[] = val.split(','/*','*/);\r\n      selectedIndice = new Array<number>(array2.length);\r\n      for (let iCtr: number = 0; iCtr < array2.length; iCtr = iCtr + 1) {\r\n        let num: number = NNumber.Parse(array2[iCtr]);\r\n        selectedIndice[iCtr] = ((num >= 0) ? num : -1);\r\n      }\r\n    }\r\n    return selectedIndice;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns true is multi selection list box else false.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  IsMultipleSelectionListBox(): boolean {\r\n    return super.isListBox();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns true if control picture is date or time\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  IsDateTimePicture(): boolean {\r\n    return this._pic.getAttr() === StorageAttribute.DATE || this._pic.getAttr() === StorageAttribute.TIME;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   this control support data source\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  SupportsDataSource(): boolean {\r\n    return super.isSelectionCtrl() || super.isTabControl() || super.isRadio() || this.HasAutocomplete() ;\r\n  }\r\n\r\n  HasAutocomplete() {\r\n    if (super.isTextControl())\r\n      return this.getProp(PropInterface.PROP_TYPE_AUTO_COMPLETE_MODE_WC).GetComputedValueBoolean();\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns the array of indice which corresponds to a specific link value\r\n  /// </summary>\r\n  /// <param name = \"mgVal\">the requested value</param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name = \"isNull\">true if mgVal represents a null value</param>\r\n  /// <returns> array of indice</returns>\r\n  async getIndexOfChoice(mgVal: string, line: number, isNull: boolean): Promise<number[]> {\r\n\r\n    // if the control is listbox with single selection mode, and the value is comma separated, then we should not split value on comma.\r\n    let splitCommaSeperatedVals: boolean = this.IsMultipleSelectionListBox();\r\n\r\n    await this.computeChoice(line);\r\n\r\n    let isVectorValue: boolean = this.getField() !== null && this.getField().getType() === StorageAttribute.BLOB_VECTOR;\r\n    return this.getDcVals().getIndexOf(mgVal, isVectorValue, isNull, this._choiceLinks.get_Item(line), this._choiceNums.get_Item(line), splitCommaSeperatedVals);\r\n  }\r\n\r\n  /// <returns> parsed content of PROP_TYPE_DISPLAY_LIST</returns>\r\n  async getDispVals(line: number, execComputeChoice: boolean): Promise<string[]> {\r\n    if (execComputeChoice) {\r\n      await this.computeChoice(line);\r\n    }\r\n    if (super.isTabControl()) {\r\n      return this._orgChoiceDisps.get_Item(line);\r\n    }\r\n    else {\r\n      return this._choiceDisps.get_Item(line);\r\n    }\r\n\r\n  }\r\n\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"line\"></param>\r\n  /// <returns></returns>\r\n  private emptyChoice(line: number): void {\r\n    let value: string[] = new Array<string>(0);\r\n    this._choiceDisps.set_Item(line, value);\r\n    this._orgChoiceDisps.set_Item(line, value);\r\n    this._choiceLinks.set_Item(line, value);\r\n    this._choiceLayerList.set_Item(line, value);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   computes the choices of a SELECT control that originate from the control's properties (in contrast to\r\n  ///   the ones originating from the underlaying table of a data control)\r\n  /// </summary>\r\n  private async computeChoice(line: number): Promise<void> {\r\n    let fromHelp: string[] = [\r\n      \"\\\\\\\\\", \"\\\\-\", \"\\\\,\"\r\n    ];\r\n    let toHelp: string[] = [\r\n      \"XX\", \"XX\", \"XX\"\r\n    ];\r\n    let task: GuiTaskBase = this.getForm().getTask();\r\n    let dataView: GuiDataViewBase = task.DataView;\r\n    let dcv: DcValues = dataView.getDcValues(this._dcValId);\r\n    let currDcId: number = this.getDcRef();\r\n    let choiceDispStr: string = null;\r\n    let choiceLinkStr: string = \"\";\r\n    let optionsValid: boolean = true;\r\n    let trimToLength: number = -1;\r\n    let dataType: StorageAttribute = this.DataType;\r\n    let isItemsListTreatedAsDisplayList: boolean = false;\r\n\r\n    try {\r\n\r\n      // re-compute values only if they are not valid or the DC was changed (due toHelp recompute)\r\n      if (this._choiceLinks.get_Item(line) === null || (this.isDataCtrl() && currDcId !== this._dcValId)) {\r\n        if (dataType === StorageAttribute.BLOB_VECTOR) {\r\n          dataType = this.getField().getCellsType();\r\n        }\r\n        let dispVals: string[] = dcv.getDispVals();\r\n        let dispProp: Property = this.getProp(PropInterface.PROP_TYPE_DISPLAY_LIST);\r\n        let linkProp: Property = this.getProp(PropInterface.PROP_TYPE_LABEL);\r\n        if (dispProp !== null) {\r\n          choiceDispStr = await dispProp.getValue();\r\n        }\r\n        if (linkProp !== null) {\r\n          choiceLinkStr = await linkProp.getValue();\r\n        }\r\n        if (choiceLinkStr === null || StrUtil.rtrim(choiceLinkStr).length === 0) {\r\n          choiceLinkStr = \"\";\r\n        }\r\n        if (choiceDispStr === null || StrUtil.rtrim(choiceDispStr).length === 0) {\r\n          if (!this.isDataCtrl() || dispVals === null || dispVals.length === 0) {\r\n            choiceDispStr = choiceLinkStr;\r\n          }\r\n          else {\r\n            choiceDispStr = (choiceLinkStr = \"\");\r\n          }\r\n          isItemsListTreatedAsDisplayList = true;\r\n        }\r\n        choiceDispStr = Events.Translate(choiceDispStr);\r\n        if (dataType === StorageAttribute.NUMERIC) {\r\n          choiceLinkStr = StrUtil.searchAndReplace(choiceLinkStr, \"\\\\-\", \"-\");\r\n        }\r\n        let helpStr: string = StrUtil.searchAndReplace(choiceLinkStr, fromHelp, toHelp);\r\n        let sTok: string[] = StrUtil.tokenize(helpStr, \",\");\r\n        let linkSize: number = (helpStr !== \"\") ? sTok.length : 0;\r\n        let helpStrDisp: string = StrUtil.searchAndReplace(choiceDispStr, fromHelp, toHelp);\r\n        sTok = StrUtil.tokenize(helpStrDisp, \",\");\r\n        let displaySize: number = (helpStrDisp !== \"\") ? sTok.length : 0;\r\n\r\n        if (linkSize !== displaySize && displaySize > 0) {\r\n          choiceDispStr = choiceLinkStr;\r\n          isItemsListTreatedAsDisplayList = true;\r\n        }\r\n        let size: number = linkSize;\r\n        let choiceLink: string[] = new Array<string>(size);\r\n        this._choiceLinks.set_Item(line, choiceLink);\r\n        if (dataType === StorageAttribute.NUMERIC || dataType === StorageAttribute.DATE || dataType === StorageAttribute.TIME) {\r\n          this._choiceNums.set_Item(line, new Array<NUM_TYPE>(size));\r\n        }\r\n\r\n        // Add display values\r\n        let orgChoiceDisp: string[] = ChoiceUtils.GetDisplayListFromString(choiceDispStr, false, true, !isItemsListTreatedAsDisplayList);\r\n        this._orgChoiceDisps.set_Item(line, orgChoiceDisp);\r\n        let choiceDisp: string[] = ChoiceUtils.GetDisplayListFromString(choiceDispStr, super.isSelectionCtrl() || super.isTabControl(), true, !isItemsListTreatedAsDisplayList);\r\n        this._choiceDisps.set_Item(line, choiceDisp);\r\n        if (this.getField() !== null) {\r\n          trimToLength = this.getField().getSize();\r\n        }\r\n\r\n\r\n        let token: string = null;\r\n        let helpToken: string = null;\r\n        let tokenBuffer: StringBuilder;\r\n        // Add link values.\r\n        for (let i: number = 0, currPos: number = 0, nextPos = 0; i < size && optionsValid; i++) {\r\n          nextPos = currPos;\r\n          nextPos = helpStr.indexOf(',', nextPos);\r\n\r\n          if (nextPos === currPos)\r\n            token = helpToken = \"\";\r\n          else if (nextPos === -1) {\r\n            token = choiceLinkStr.substr(currPos);\r\n            helpToken = helpStr.substr(currPos);\r\n          }\r\n          else {\r\n            token = choiceLinkStr.substr(currPos, (nextPos) - (currPos));\r\n            helpToken = helpStr.substr(currPos, (nextPos) - (currPos));\r\n          }\r\n\r\n          currPos = nextPos + 1;\r\n\r\n          switch (dataType) {\r\n            case StorageAttribute.ALPHA:\r\n            case StorageAttribute.MEMO:\r\n            case StorageAttribute.UNICODE:\r\n            case StorageAttribute.BLOB_VECTOR:\r\n              token = StrUtil.ltrim(token);\r\n              helpToken = StrUtil.ltrim(helpToken);\r\n              if (helpToken.indexOf('\\\\') >= 0) {\r\n                tokenBuffer = new StringBuilder();\r\n                for (let tokenPos: number = 0; tokenPos < helpToken.length; tokenPos++)\r\n                  if (helpToken[tokenPos] !== '\\\\')\r\n                    tokenBuffer.Append(token[tokenPos]);\r\n                  else if (tokenPos === helpToken.length - 1)\r\n                    tokenBuffer.Append(' ');\r\n\r\n                token = tokenBuffer.ToString();\r\n              }\r\n              token = StrUtil.makePrintableTokens(token, SEQ_2_STR);\r\n              if (this.isSelectionCtrl() || this.isTabControl())\r\n                token = ChoiceUtils.RemoveAcclCharFromOptions(new StringBuilder(token));\r\n\r\n              // choiceLink size cannot be greater than size of the field, so trim it.\r\n              if (UtilStrByteMode.isLocaleDefLangDBCS() && dataType === StorageAttribute.ALPHA) {\r\n                if (trimToLength !== -1 && UtilStrByteMode.lenB(token) > trimToLength)\r\n                  token = UtilStrByteMode.leftB(token, trimToLength);\r\n              }\r\n              else {\r\n                if (trimToLength !== -1 && token.length > trimToLength)\r\n                  token = token.substr(0, trimToLength);\r\n              }\r\n\r\n              choiceLink[i] = token;\r\n              break;\r\n\r\n            case StorageAttribute.NUMERIC:\r\n            case StorageAttribute.DATE:\r\n            case StorageAttribute.TIME:\r\n              let picture: PIC = PIC.buildPicture(dataType, token, task.getCompIdx(), false);\r\n              optionsValid = this.optionIsValid(token);\r\n              choiceLink[i] = DisplayConvertor.Instance.disp2mg(token.trim(), picture,\r\n                                                                task.getCompIdx(),\r\n                                                                BlobType.CONTENT_TYPE_UNKNOWN);\r\n              ((this._choiceNums.get_Item(line)))[i] = new NUM_TYPE(choiceLink[i]);\r\n              break;\r\n\r\n            case StorageAttribute.BOOLEAN:\r\n              choiceLink[i] = (1 - i).toString();\r\n              break;\r\n\r\n            default:\r\n              break;\r\n          }\r\n        }\r\n\r\n        if (!optionsValid)\r\n          this.emptyChoice(line);\r\n      }\r\n    } catch (ex) {\r\n      if (ex instanceof Exception) {\r\n        optionsValid = false;\r\n        this.emptyChoice(line);\r\n        Events.WriteExceptionToLog(NString.Format(\"{0} : {1}\", ex.GetType(), ex.Message));\r\n      }\r\n      else\r\n        throw ex;\r\n    }\r\n    this._hasValidItmAndDispVal = optionsValid;\r\n\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the topmost form of the subform\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getTopMostForm(): MgFormBase {\r\n    return this.getForm().getTopMostForm();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   replace the url on browser control\r\n  /// </summary>\r\n  private setUrl(): void {\r\n    Commands.addValueWithLine(CommandType.SET_VALUE, this, 0, this.Value);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value in internal representation without changing the control value\r\n  /// </summary>\r\n  /// <param name = \"dispVal\">the displayed value with the masking characters</param>\r\n  async getMgValue(dispVal: any): Promise<string> {\r\n    let mgVal: string = null;\r\n\r\n    if (super.isCheckBox()) {\r\n      mgVal = dispVal ? \"1\" : \"0\";\r\n    }\r\n    else {\r\n      if (super.isSelectionCtrl() || super.isTabControl() || super.isRadio()) {\r\n\r\n        let line: number = this.getDisplayLine(true);\r\n\r\n        if (line < 0)\r\n          line = 0;\r\n\r\n        if (typeof dispVal === \"number\")\r\n          dispVal = dispVal.toString();\r\n\r\n        if (Array.isArray(dispVal))\r\n          dispVal = dispVal.join(',').toString();\r\n\r\n\r\n        if (dispVal === \"\") {\r\n          mgVal = dispVal;\r\n        }\r\n        else {\r\n          mgVal = await this.getLinkValue(dispVal, line);\r\n        }\r\n        if (mgVal === null) {\r\n          let isNull: boolean = false;\r\n          // The data control will never return an illegal value as a result of a user selection\r\n          // but as a result of an init expression, update operation or values of data in\r\n          // the record. Therefore, the same illegal value should be taken from its source,\r\n          // which is a field or an expression. (Ehud 19-jun-2001)\r\n          let refMgVal: RefParam<string> = new RefParam<string>(mgVal);\r\n          let refIsNull: RefParam<boolean> = new RefParam<boolean>(isNull);\r\n\r\n          if (this._field !== null) {\r\n            mgVal = refMgVal.value;\r\n          }\r\n        }\r\n      }\r\n      else {\r\n        let blobContentType: string = (this._field !== null) ? this._field.getContentType() : BlobType.CONTENT_TYPE_UNKNOWN;\r\n        mgVal = DisplayConvertor.Instance.disp2mg(dispVal, this._pic, this.getForm().getTask().getCompIdx(), blobContentType);\r\n      }\r\n    }\r\n    return mgVal;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns comma separated values for indice passed.\r\n  /// </summary>\r\n  /// <param name=\"selectedIndice\">comma separated values</param>\r\n  /// <param name=\"line\"></param>\r\n  /// <returns>comma separated values</returns>\r\n  async getLinkValue(selectedIndice: string, line: number): Promise<string> {\r\n    let size: number = 0;\r\n    let result: string = NString.Empty;\r\n    let temp: List<string> = new List<string>();\r\n\r\n    await this.computeChoice(line);\r\n\r\n    let choiceLink: string[] = this._choiceLinks.get_Item(line);\r\n\r\n    if (choiceLink !== null) {\r\n      // compute size of displayed values array\r\n      size = choiceLink.length;\r\n    }\r\n    let linkIndice: number[] = this.getLinkIdxFromLayer(Misc.GetIntArray(selectedIndice));\r\n\r\n    let array2: number[] = linkIndice;\r\n    for (let i: number = 0; i < array2.length; i = i + 1) {\r\n      let idx: number = array2[i];\r\n      if (idx >= size) {\r\n        let dcVals: DcValues = this.getDcVals();\r\n        temp.push(dcVals.getLinkValue(idx - size));\r\n      }\r\n      else {\r\n        if (idx >= 0 && idx < choiceLink.length) {\r\n          temp.push(choiceLink[idx]);\r\n        }\r\n        else {\r\n          temp.push(null);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (this.DataType === StorageAttribute.BLOB_VECTOR) {\r\n      let vectorType: VectorType = new VectorType(this.getField());\r\n      for (let indx: number = 0; indx < temp.length; indx = indx + 1) {\r\n        vectorType.setVecCell(indx + 1, temp.get_Item(indx), temp.get_Item(indx) === null);\r\n      }\r\n      result = vectorType.toString();\r\n    }\r\n    else {\r\n      if (temp.length > 1) {\r\n        result = temp.join(\",\");\r\n      }\r\n      else {\r\n        result = temp.get_Item(0);\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set text on the control\r\n  /// </summary>\r\n  private setText(): void {\r\n    let displayLine: number = this.getDisplayLine(true);\r\n    let mlsTranslatedValue: any = this.Value;\r\n    if (super.isButton()) {\r\n      mlsTranslatedValue = Events.Translate(this.Value);\r\n    }\r\n    if (this.isTextControl() || this.isButton())\r\n      Commands.addValueWithLine(CommandType.SET_VALUE, this, displayLine, mlsTranslatedValue);\r\n    else\r\n      Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, displayLine, /*\"innerHTML\"*/ HtmlProperties.Text, mlsTranslatedValue);\r\n\r\n    // Commands.addAsync(CommandType.PROP_SET_TEXT, this, displayLine, mlsTranslatedValue, 0);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   set the radio button checked\r\n  /// </summary>\r\n  /// <param name = \"radioLine\">is the line of the radio that need to be Set</param>\r\n  private setRadioChecked(index: number): void {\r\n\r\n    Commands.addValueWithLine(CommandType.SET_VALUE, this, this.getDisplayLine(false), index);\r\n    Commands.beginInvoke();\r\n\r\n    // set control to focus\r\n    if (index !== GuiConstants.DEFAULT_VALUE_INT) {\r\n      this.setControlToFocus();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  setControlToFocus(): void {\r\n    if (this.getField() !== null) {\r\n      this.getField().ControlToFocus = this;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set CheckBox Value to the check box control\r\n  /// </summary>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"mgVal\"></param>\r\n  /// <returns></returns>\r\n  private setCheckBoxValue(line: number, mgVal: string): void {\r\n    let checkState: boolean = DisplayConvertor.toBoolean(mgVal);\r\n    Commands.addValueWithLine(CommandType.SET_VALUE, this, line, checkState);\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"line\"></param>\r\n  /// <param name = \"valueChanged\"></param>\r\n  /// <returns></returns>\r\n  private async refreshAndSetItemListByDataSource(line: number, valueChanged: boolean): Promise<boolean> {\r\n    if (this.SupportsDataSource()) {\r\n      let currDcId: number = this.getDcRef();\r\n\r\n      // If the range was changed we have to recalculate the correct choice option\r\n      if (this._rangeChanged) {\r\n        valueChanged = true;\r\n      }\r\n      this._rangeChanged = false;\r\n      if (this.isDataCtrl() && currDcId !== this._dcValId) {\r\n\r\n        // Performance improvement: server writes optionList to the HTML. No need to apply\r\n        // them\r\n        // for the first time.\r\n        // force update of the value whenever the set of options is replaced\r\n        // if (form.formRefreshed() || forceRefresh)\r\n\r\n        valueChanged = true;\r\n        await this.refreshAndSetItemsList(line, true);\r\n        this.setDcRef(this._dcValId);\r\n      }\r\n    }\r\n    return valueChanged;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the dcref for the current table line\r\n  /// </summary>\r\n  /// <param name = \"dcId\">the new reference to the dcvals</param>\r\n  setDcRef(dcId: number): void {\r\n    this._dcTableRefs.set_Item(this.getDcLineNum(), dcId);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   replace the image list of an button control with the image at the given URL\r\n  /// </summary>\r\n  setImageList(url: string): void {\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Update boolean property(ex:visible\\enable) of control and it's children\r\n  /// </summary>\r\n  /// <param name = \"propId\">property id </param>\r\n  /// <param name = \"commandType\">command type that belong to the prop id</param>\r\n  /// <param name = \"val\"></param>\r\n  /// <param name = \"updateThis\"></param>\r\n  async updatePropertyLogicNesting(propId: number, commandType: CommandType, val: boolean, updateThis: boolean): Promise<void> {\r\n    // if (val && this.haveToCheckParentValue()) {\r\n    //  val = this.isParentPropValue(propId);\r\n    // }\r\n    if (updateThis) {\r\n\r\n      Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false),\r\n                                    commandType === CommandType.PROP_SET_VISIBLE ? HtmlProperties.Visible : HtmlProperties.Enabled, val);\r\n\r\n    }\r\n    // todo: should go over only linked controls - not children controls, need to check with PM this behavior\r\n    await this.updateChildrenPropValue(propId, commandType, val);\r\n  }\r\n\r\n  SetEnabled(val: boolean): void {\r\n    Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.Enabled, val);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Updates visibility of controls linked to the control\r\n  /// </summary>\r\n  /// <param name = \"propId\"></param>\r\n  /// <param name = \"commandType\"></param>\r\n  /// <param name = \"val\"></param>\r\n  async updateChildrenPropValue(propId: number, commandType: CommandType, val: boolean): Promise<void> {\r\n\r\n    if (!super.isTableControl()) {\r\n      // in table all children are contained,\r\n      // table's visibility\\enable will affect them\r\n\r\n      for (let i: number = 0; i < this._linkedControls.length; i = i + 1) {\r\n\r\n        let child: MgControlBase = this._linkedControls.get_Item(i);\r\n        // Defect 117294. Do not continue for the first time. It affects on the placement.\r\n        if (child.IsFirstRefreshOfProps())\r\n          continue;\r\n\r\n        let childValue: boolean = (child.GetComputedBooleanProperty(propId, true));\r\n\r\n        childValue = childValue && val;\r\n\r\n        let childOnCurrentLayer: boolean = this.isChildOnCurrentLayer(child);\r\n\r\n        if (commandType === CommandType.PROP_SET_VISIBLE) {\r\n\r\n          if (childValue) {\r\n            childValue = childOnCurrentLayer;\r\n          }\r\n          await child.updateChildrenPropValue(propId, commandType, childValue);\r\n        }\r\n      }\r\n      if (super.isSubform()) {\r\n         await this.updateSubformChildrenPropValue(propId, commandType, val);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return true if this control is descendant of specified control\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isDescendentOfControl(control: GuiMgControl): boolean {\r\n    let isContained: boolean = false;\r\n\r\n    if (control !== null) {\r\n      let parent: any = this.getParent();\r\n      if (parent instanceof MgControlBase) {\r\n        if (parent === control) {\r\n          isContained = true;\r\n        }\r\n        else {\r\n          // If current control belongs to table, then it is also a descendant of the column control to\r\n          // which it belongs. According to our hierarchy, the control is direct descendant of table\r\n          // control; hence, we need to handle column control\r\n\r\n          let parentControl: MgControlBase = ((parent instanceof MgControlBase) ? <MgControlBase>parent : null);\r\n          if (control.Type === MgControlType.CTRL_TYPE_COLUMN && parentControl !== null && parentControl.Type === MgControlType.CTRL_TYPE_TABLE && control.Layer === this.Layer)\r\n            isContained = true;\r\n          else\r\n            isContained = ((<MgControlBase>parent).isDescendentOfControl(control));\r\n        }\r\n      }\r\n    }\r\n    return isContained;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Updates visibility or enable property of subform controls\r\n  /// </summary>\r\n  /// <param name = \"propId\">Id of visibility or enable property</param>\r\n  /// <param name = \"commandType\">type of the GUI command</param>\r\n  /// <param name = \"val\">value for the property</param>\r\n  updateSubformChildrenPropValue(propId: number, commandType: CommandType, val: boolean): void {\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks child's layer is equal to current layer of the parent, relavant for tab control for all other\r\n  ///   controls returns true\r\n  /// </summary>\r\n  /// <param name = \"child\"></param>\r\n  /// <returns> true if parent is not tab control or parent is tab control with same layer</returns>\r\n  isChildOnCurrentLayer(child: MgControlBase): boolean {\r\n    let ret: boolean = true;\r\n    // check that the control has same layer that is currently set on it's parent tab control\r\n    if (super.isChoiceControl()) {\r\n      let parentLayer: number = 0;\r\n      if (this.Value !== null) {\r\n        parentLayer = this.getCurrentLinkIdx() + 1;\r\n      }\r\n      let layer: number = child.getLayer();\r\n      if (parentLayer !== layer && layer > 0) {\r\n        // sons of layer 0 displayed always\r\n        ret = false;\r\n      }\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Return current link Idx of choice controls, or zero for others\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getCurrentLinkIdx(): number {\r\n    let currLinkIdx: number = 0;\r\n\r\n    if (super.isChoiceControl() || this.HasAutocomplete()) {\r\n      let currentLayers: number[] = this.getCurrentIndexOfChoice();\r\n      let currLinkIndice: number[] = this.getLinkIdxFromLayer(currentLayers);\r\n      currLinkIdx = currLinkIndice[0];\r\n    }\r\n    return currLinkIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  /// gets layer from the selected indice passed.\r\n  /// </summary>\r\n  /// <param name=\"linkIdx\"></param>\r\n  /// <returns>array of layer values.</returns>\r\n  getLayerFromLinkIdx(indice: number[]): number[] {\r\n    let layers: number[] = new Array<number>(indice.length);\r\n\r\n    for (let iCtr: number = 0; iCtr < indice.length; iCtr = iCtr + 1) {\r\n      let idx: number = indice[iCtr];\r\n      // By default, layer = linkIdx unless it is a Tab control\r\n\r\n      layers[iCtr] = idx;\r\n\r\n      if (super.isTabControl() && idx >= 0) {\r\n        let line: number = this.getDisplayLine(false);\r\n        if (line < 0) {\r\n          line = 0;\r\n        }\r\n        let layerList: string[] = this._choiceLayerList.get_Item(line);\r\n        if (layerList !== null && layerList.length > 0) {\r\n          layers[iCtr] = layerList.indexOf((idx + 1).toString());\r\n        }\r\n      }\r\n    }\r\n    return layers;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets the selected indice for selected values.\r\n  /// </summary>\r\n  /// <param name=\"layers\">an array of current layers tab controls. It can be array because of multiple selection.</param>\r\n  /// <returns>array of indice</returns>\r\n  private getLinkIdxFromLayer(layers: number[]): number[] {\r\n    let linkIndice: number[] = new Array<number>(layers.length);\r\n    for (let iCtr: number = 0; iCtr < layers.length; iCtr = iCtr + 1) {\r\n      let layer: number = layers[iCtr];\r\n      linkIndice[iCtr] = layer;\r\n      if (super.isTabControl()) {\r\n        if (layer < 0) {\r\n          linkIndice[iCtr] = 0;\r\n        }\r\n        else {\r\n          let line: number = this.getDisplayLine(false);\r\n          if (line < 0) {\r\n            line = 0;\r\n          }\r\n          let layerList: string[] = this._choiceLayerList.get_Item(line);\r\n          if (layerList !== null && typeof layerList !== \"undefined\" && layerList.length !== 0 && layer < layerList.length) {\r\n            linkIndice[iCtr] = NNumber.Parse(layerList[layer]) - 1;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return linkIndice;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   recursive method, checks if parent of the child is visible\\enable, ultil there is no parent or found\r\n  ///   parent that is hidden\r\n  /// </summary>\r\n  /// <param name = \"propId\"></param>\r\n  /// <returns></returns>\r\n  isParentPropValue(propId: number): boolean {\r\n    let column: MgControlBase = this.Form.getControlColumn(this);\r\n    let parent: MgControlBase = <MgControlBase>this.getLinkedParent(true);\r\n\r\n    let result: boolean;\r\n\r\n    if (parent === null) {\r\n      // no more parents\r\n      result = true;\r\n    }\r\n    else {\r\n      // parent is hidden\r\n      if (!parent.GetComputedBooleanProperty(propId, true)) {\r\n        result = false;\r\n      }\r\n      else {\r\n        if (!parent.isChildOnCurrentLayer(this)) {\r\n          // parent is tab control with current layer\r\n          // different from child's layer\r\n          result = false;\r\n        }\r\n        else {\r\n          // for table children check if column visible\r\n          result = (!(column !== null && !column.GetComputedBooleanProperty(propId, true)) && parent.isParentPropValue(propId));\r\n        }\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get control to which this control is linked\r\n  /// </summary>\r\n  /// <param name = \"checkSubformFather\">if true check for Subform control</param>\r\n  /// <returns></returns>\r\n  getLinkedParent(checkSubformFather: boolean): GuiControlPropertyAdapter {\r\n\r\n    if (this._linkedParentDitIdx !== -1) {\r\n      return this.Form.getCtrl(this._linkedParentDitIdx);\r\n    }\r\n    else {\r\n      if (checkSubformFather && this.Form.isSubForm()) {\r\n        return this.Form.getSubFormCtrl();\r\n      }\r\n      else {\r\n        return null;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the current line value of the readOnly history array\r\n  /// </summary>\r\n  /// <param name = \"newVal\">the new value to be set</param>\r\n  SetCurrReadOnly(newVal: boolean): void {\r\n    this._currReadOnly.set_Item(this.getDisplayLine(true), newVal);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the current readOnly value according to the control's current line number\r\n  /// </summary>\r\n  /// <returns> the readOnly value</returns>\r\n  GetCurrReadOnly(): boolean {\r\n    let line: number = super.isTableControl() ? 0 : this.getDisplayLine(true);\r\n    let currObj: any = this._currReadOnly.get_Item(line);\r\n    let curr: boolean;\r\n    if (currObj === null) {\r\n      curr = false;\r\n      this._currReadOnly.set_Item(line, curr);\r\n    }\r\n    else {\r\n      curr = <boolean>currObj;\r\n    }\r\n    return curr;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if this control is a Data Control\r\n  /// </summary>\r\n  isDataCtrl(): boolean {\r\n    return this._dataCtrl;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the dcref according to the current line number\r\n  /// </summary>\r\n  /// <returns> the dcId</returns>\r\n  getDcRef(): number {\r\n    let line: number = this.getDcLineNum();\r\n    let obj: any = this._dcTableRefs.get_Item(this.getDcLineNum());\r\n    let dcId: number;\r\n    if (obj === null) {\r\n      dcId = -2;\r\n      this._dcTableRefs.set_Item(line, dcId);\r\n    }\r\n    else {\r\n      dcId = <number>obj;\r\n    }\r\n    return dcId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the current line number for a data control\r\n  /// </summary>\r\n  private getDcLineNum(): number {\r\n    return this.IsRepeatable ? this.Form.DisplayLine : 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if the one choice option from items list is valid. The check is only for items list and not for the\r\n  ///   data source options, (FYI: for the option from the DataCtrl, we are not calling this\r\n  ///   method, NO CHECK IS DONE) in online :ci_check_range_str\r\n  /// </summary>\r\n  /// <param name = \"option:\">one option from the items list</param>\r\n  /// <returns></returns>\r\n  private optionIsValid(option: string): boolean {\r\n    let isValid: boolean = true;\r\n\r\n    if (this.DataType === StorageAttribute.NUMERIC && option.length > 0 && option.indexOf('0') === -1) {\r\n      let convertNum: NUM_TYPE = new NUM_TYPE();\r\n      convertNum.num_4_a_std(option);\r\n      if (convertNum.num_is_zero()) {\r\n        isValid = false;\r\n      }\r\n    }\r\n    return isValid;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   prepares and returns the ordered list based on layers in layerList\r\n  /// </summary>\r\n  /// <param name = \"choiceDispList\">unordered list</param>\r\n  /// <returns></returns>\r\n  private async getOrderedDispList(choiceDispList: string[], line: number): Promise<string[]> {\r\n\r\n    let choiceLayerStr: string = \"\";\r\n    let dispArryList: List<string> = new List<string>();\r\n    let layerArryList: List<string> = new List<string>();\r\n    let layerProp: Property = this.getProp(PropInterface.PROP_TYPE_VISIBLE_LAYERS_LIST);\r\n\r\n    if (layerProp !== null) {\r\n      choiceLayerStr = await layerProp.getValue();\r\n    }\r\n\r\n    if (choiceLayerStr === null || StrUtil.rtrim(choiceLayerStr).length === 0) {\r\n      choiceLayerStr = \"\";\r\n    }\r\n    if (choiceLayerStr.length > 0 && choiceDispList.length > 0) {\r\n      let layerList: string[] = choiceLayerStr.split(\",\");\r\n      let posCopyIndex: number = -1;\r\n      for (let index: number = 0; index < layerList.length; index = index + 1) {\r\n        let currLayerListVal: string = layerList[index].trim();\r\n        if (!(layerArryList.indexOf(currLayerListVal) !== -1)) {\r\n          let refPosCopyIndex: RefParam<number> = new RefParam<number>(posCopyIndex);\r\n          let isNumber: boolean = NNumber.TryParse(currLayerListVal, refPosCopyIndex);\r\n          posCopyIndex = refPosCopyIndex.value;\r\n\r\n          // posCopyIndex is 1Based, so must not be zero. Also, it must not be\r\n          // greater than no of elements in the DiplayList.\r\n\r\n          if (isNumber && posCopyIndex > 0 && posCopyIndex <= choiceDispList.length) {\r\n            dispArryList.push((choiceDispList[posCopyIndex - 1]).trim());\r\n            layerArryList.push(currLayerListVal);\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    let result: string[];\r\n    if (dispArryList.length === 0) {\r\n      result = choiceDispList;\r\n      this._choiceLayerList.set_Item(line, new Array<string>(0));\r\n    }\r\n    else {\r\n      result = new Array<string>(dispArryList.length);\r\n      for (let _ai: number = 0; _ai < result.length; ++_ai)\r\n        result[_ai] = null;\r\n\r\n      result = dispArryList.ToArray();\r\n      this._choiceLayerList.set_Item(line, layerArryList.ToArray());\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset the previous value\r\n  /// </summary>\r\n  resetPrevVal(): void {\r\n    let line: number = this.getDisplayLine(true);\r\n    if (line < 0) {\r\n      line = 0;\r\n    }\r\n    this._prevValues.set_Item(line, null);\r\n    this.setPrevIsNull_ToNull();\r\n  }\r\n\r\n  ///   sets the prevIsNull value of the prevIsNull array\r\n  ///   the newValue can be NULL or bool\r\n  /// </summary>\r\n  setPrevIsNull_ToNull(): void {\r\n    this._prevIsNulls.set_Item(this.getDisplayLine(true), null);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns>true if an expression was set as the data</returns>\r\n  expressionSetAsData(): boolean {\r\n    return this._valExpId > 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   called whenever the choice list of a SELECT control has changed\r\n  /// </summary>\r\n  clearRange(line: number): void {\r\n    this._orgChoiceDisps.set_Item(line, null);\r\n    this._choiceDisps.set_Item(line, null);\r\n    this._choiceLinks.set_Item(line, null);\r\n    this._choiceLayerList.set_Item(line, null);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   have to check parent visibility\\enable\r\n  /// </summary>\r\n  /// <returns>true, if the control is connected to a container or the task is a subfom</returns>\r\n  haveToCheckParentValue(): boolean {\r\n    let ret: boolean = false;\r\n    if (this._linkedParentDitIdx !== -1) {\r\n\r\n      if (!this.isContainedInLinkedParent()) {\r\n        ret = true;\r\n      }\r\n      // contained tab children of all layers are on the same window,\r\n      // so we must handle there visibility\\enable\r\n\r\n      else {\r\n        if (this.Form.getCtrl(this._linkedParentDitIdx).isTabControl() || this.Form.getCtrl(this._linkedParentDitIdx).isGroup()) {\r\n          ret = true;\r\n        }\r\n      }\r\n    }\r\n    else {\r\n      if (this.Form.isSubForm()) {\r\n        ret = true;\r\n      }\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if control is contain in its linked parent\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isContainedInLinkedParent(): boolean {\r\n    return this._containerDitIdx !== -1 && this._containerDitIdx === this._linkedParentDitIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Combine two strings array into one. Each of the original arrays may be null.\r\n  /// </summary>\r\n  /// <param name = \"firstStrings\">the first strings array that will always occupy the first array cells</param>\r\n  /// <param name = \"lastStrings\">the last strings array that will always occupy the last array cells</param>\r\n  /// <returns> combined Strings array</returns>\r\n  private static combineStringArrays(firstStrings: string[], lastStrings: string[]): string[] {\r\n    let result: string[] = new Array<string>();\r\n\r\n    if (firstStrings !== null)\r\n      result = result.concat(firstStrings);\r\n\r\n    if (lastStrings !== null)\r\n      result = result.concat(lastStrings);\r\n\r\n    return result;\r\n  }\r\n\r\n\r\n  GetComputedBooleanProperty(propId: number, defaultRetVal: boolean, line?: number): boolean {\r\n    if (arguments.length === 2 && (propId === null || propId.constructor === Number) && (defaultRetVal === null || defaultRetVal.constructor === Boolean)) {\r\n      return this.GetComputedBooleanProperty_0(propId, defaultRetVal);\r\n    }\r\n    return this.GetComputedBooleanProperty_1(propId, defaultRetVal, line);\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the boolean computed value of a property of the control\r\n  /// </summary>\r\n  /// <param name = \"propId\">the id of the property</param>\r\n  /// <param name = \"defaultRetVal\">the default return value (when the property does not exist)</param>\r\n  private GetComputedBooleanProperty_0(propId: number, defaultRetVal: boolean): boolean {\r\n    let result: boolean = defaultRetVal;\r\n    let prop: Property = this.GetComputedProperty(propId);\r\n    if (prop !== null) {\r\n      result = prop.GetComputedValueBoolean();\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the boolean value of a property of the control - if the control is repeatable and the line is\r\n  /// different than the forms current line then return the previous value of the control property at that line\r\n  /// </summary>\r\n  /// <param name = \"propId\">the id of the property</param>\r\n  /// <param name = \"defaultRetVal\">the default return value (when the property does not exist)</param>\r\n  /// <param name = \"line\">the line number in table in which the control is located</param>\r\n  private GetComputedBooleanProperty_1(propId: number, defaultRetVal: boolean, line: number): boolean {\r\n    let result: boolean = defaultRetVal;\r\n\r\n    if (this.isPropertyRepeatable(propId) && this.Form.DisplayLine !== line) {\r\n      let prop: Property = this.GetComputedProperty(propId);\r\n      if (prop !== null) {\r\n        let val: string = prop.getPrevValue(line);\r\n        if (val !== null) {\r\n          result = DisplayConvertor.toBoolean(val);\r\n        }\r\n      }\r\n    }\r\n    else {\r\n      result = this.GetComputedBooleanProperty(propId, defaultRetVal);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the boolean value of a property of the control - if the control is repeatable and the line is\r\n  ///   different than the forms current line then return the previous value of the control property at that\r\n  ///   line\r\n  /// </summary>\r\n  /// <param name = \"propId\">the id of the property</param>\r\n  /// <param name = \"defaultRetVal\">the default return value (when the property does not exist)</param>\r\n  /// <param name = \"line\">the line number in table in which the control is located</param>\r\n  async checkPropWithLine(propId: number, defaultRetVal: boolean, line: number): Promise<boolean> {\r\n    let result: boolean = defaultRetVal;\r\n\r\n    if (this.isPropertyRepeatable(propId) && this.Form.DisplayLine !== line) {\r\n      let prop: Property = this.getProp(propId);\r\n      if (prop !== null) {\r\n        let val: string = prop.getPrevValue(line);\r\n        if (val !== null) {\r\n          result = DisplayConvertor.toBoolean(val);\r\n        }\r\n      }\r\n    }\r\n    else {\r\n      result = await this.checkProp(propId, defaultRetVal);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the boolean value of a property of the control\r\n  /// </summary>\r\n  /// <param name = \"propId\">the id of the property</param>\r\n  /// <param name = \"defaultRetVal\">the default return value (when the property does not exist)</param>\r\n  async checkProp(propId: number, defaultRetVal: boolean): Promise<boolean> {\r\n    let result: boolean = defaultRetVal;\r\n    let prop: Property = this.getProp(propId);\r\n    if (prop !== null) {\r\n      result = await prop.getValueBoolean();\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if propId property is repeatable for this control\r\n  /// </summary>\r\n  /// <param name = \"propId\"></param>\r\n  /// <returns></returns>\r\n  isPropertyRepeatable(propId: number): boolean {\r\n    let isRepeatable: boolean = this.IsRepeatable;\r\n    if (isRepeatable) {\r\n      return true;\r\n    }\r\n    else {\r\n      return super.isTableControl() && Property.isRepeatableInTable();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// set the value of the control and update the display\r\n  /// </summary>\r\n  /// <param name = \"mgVal\">the value of the control in magic internal format to be displayed</param>\r\n  /// <param name=\"isNull\"></param>\r\n  async SetAndRefreshDisplayValue(mgVal: string, isNull: boolean): Promise<void> {\r\n    let dcRangeIsEmpty: boolean = true;\r\n\r\n    if (mgVal === null) {\r\n      this.Value = \"\";\r\n      // QCR 308475 - controls that are Initialized with null should be given magic default value.\r\n      if (!isNull)\r\n        mgVal = FieldDef.getMagicDefaultValue(this.DataType);\r\n    }\r\n    else {\r\n      if (super.isChoiceControl()) {\r\n        let line: number = this.getDisplayLine(true);\r\n        if (line < 0) {\r\n          line = 0;\r\n        }\r\n        let layers: number[] = this.getLayerFromLinkIdx(await this.getIndexOfChoice(mgVal, line, isNull));\r\n\r\n        // We do not allow no selection for a tab control.\r\n        // So, if there is no Tab to be selected, select the first Tab and\r\n        // also update the field's value accordingly.\r\n\r\n        if (layers[0] < 0 && super.isTabControl()) {\r\n          layers[0] = 0;\r\n          mgVal = await this.getLinkValue(layers[0].toString(), line);\r\n          isNull = false;\r\n          if (this._field !== null && mgVal !== null) {\r\n            await (<GuiTaskBase>this._field.getTask()).UpdateFieldValueAndStartRecompute(this._field, mgVal, isNull);\r\n          }\r\n        }\r\n        this.Value = Misc.GetCommaSeperatedString(layers);\r\n        dcRangeIsEmpty = false;\r\n      }\r\n    }\r\n\r\n    // QCR #450248: an empty range in the data control caused deleting the value\r\n    // of the control when leaving it. Now, the range of the control is used when\r\n    // the data control range is empty.\r\n    if (dcRangeIsEmpty) {\r\n      if (!super.isCheckBox() && (this._field === null || !isNull || !this._field.hasNullDisplayValue())) {\r\n        try {\r\n          if ((super.isImageControl() && this.DataType === StorageAttribute.BLOB) || super.IsImageButton()) {\r\n            this.Value = mgVal;\r\n          }\r\n          else {\r\n            if ((this._field === null && isNull) && (this.DataType === StorageAttribute.NUMERIC || this.DataType === StorageAttribute.DATE || this.DataType === StorageAttribute.TIME || this.DataType === StorageAttribute.BOOLEAN)) {\r\n              this.Value = mgVal;\r\n            }\r\n            else {\r\n              let inControl: boolean = this.InControl;\r\n              this.Value = DisplayConvertor.Instance.mg2disp(mgVal, this._range, this._pic, true, super.isSelectionCtrl(), this.getForm().getTask().getCompIdx(), inControl);\r\n            }\r\n          }\r\n          // Defect # 138803 : Fix to provide backwards compatibility for uniPaaS. Do not call rtrimValue() when refreshing the display if the data type\r\n          // is not numeric or left justify property is No.\r\n          if (typeof this.Value === 'string' && (!this._pic.isAttrNumeric() || this._pic.isLeft())) {\r\n            this.rtrimValue();\r\n          }\r\n        } catch (innerException) {\r\n          if (innerException instanceof ApplicationException) {\r\n            Events.WriteExceptionToLog(new ApplicationException(NString.Format(\"Control: '{0}', mgval: {1}\", this.Name, mgVal), innerException));\r\n            this.Value = \"\";\r\n            mgVal = FieldDef.getMagicDefaultValue(this.DataType);\r\n          }\r\n          else\r\n            throw innerException;\r\n        }\r\n      }\r\n      else {\r\n        if (this.isCheckBox())\r\n          this.Value = DisplayConvertor.toBoolean(mgVal);\r\n        else\r\n          this.Value = mgVal;\r\n      }\r\n    }\r\n    // Translate logical name for image control.\r\n    if ((super.isImageControl() && this.DataType !== StorageAttribute.BLOB) || super.IsImageButton()) {\r\n      mgVal = Events.TranslateLogicalName(mgVal);\r\n    }\r\n    this.IsNull = isNull;\r\n    await this.RefreshDisplayValue(mgVal);\r\n  }\r\n\r\n  /// <summary> Checks if the control's value is modified and if so, updates the ModifiedByUser </summary>\r\n  /// <param name=\"newValue\"></param>\r\n  UpdateModifiedByUser(newValue: string): void {\r\n\r\n    // For image control and image button, the value would not be changed by the user. But, if it has\r\n    // a logical name, it is replaced. Or if it is fileServer get, the value is replaced by a server url.\r\n    // In both these cases, we should not mark it as modified.\r\n    if (!(super.isButton() || super.isImageControl())) {\r\n      let ctrlCurrIsNull: boolean = this.IsNull;\r\n      let valChanged: boolean = (this.isDifferentValue(newValue, false, false));\r\n\r\n      // if the value didn't change then let's check if the nullity have changed\r\n      if (!valChanged) {\r\n        if (this.CanGetNullFromControlValue()) {\r\n          valChanged = (ctrlCurrIsNull !== this.isNullValue(newValue));\r\n        }\r\n      }\r\n      if (valChanged || this.KeyStrokeOn) {\r\n        this.ModifiedByUser = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   RTrims the control value\r\n  /// </summary>\r\n  private rtrimValue(): void {\r\n    if ((super.isImageControl() && this.DataType === StorageAttribute.BLOB) || super.IsImageButton()) {\r\n      this.Value = NString.TrimEnd(this.Value);\r\n    }\r\n    else {\r\n      let minimumValueLength: number = this.getMinimumValueLength();\r\n      // RTrim the value beyond this index\r\n      if (this.Value.length > minimumValueLength) {\r\n        let str: string = this.Value.substr(minimumValueLength);\r\n\r\n        // copy the minimum length value as is\r\n        this.Value = this.Value.substr(0, minimumValueLength);\r\n        // rtrim the value beyond minimum length\r\n        this.Value = this.Value + StrUtil.rtrimWithNull(str, true);\r\n      }\r\n\r\n      // always trim the numeric value.\r\n      if (super.isTextControl() && this.DataType === StorageAttribute.NUMERIC) {\r\n        this.Value = NString.TrimEnd(this.Value);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the minimum value length\r\n  /// </summary>\r\n  private getMinimumValueLength(): number {\r\n    let minLength: number = this._pic.getMaskLength();\r\n\r\n    // traverse from right till a valid mask char is encountered\r\n    while (minLength > 0 && !this._pic.picIsMask(minLength - 1)) {\r\n      minLength = minLength - 1;\r\n    }\r\n    return minLength;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isNullValue(str: string): boolean {\r\n    let retIsNullControl: boolean = false;\r\n    if (this.CanGetNullFromControlValue() && str === \"\") {\r\n      retIsNullControl = true;\r\n    }\r\n    return retIsNullControl;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   this control can get null value from the control himself\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  CanGetNullFromControlValue(): boolean {\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if a specific index corresponds to a null value.\r\n  /// </summary>\r\n  isChoiceNull(idx: number): boolean {\r\n    let result: boolean;\r\n    if (idx >= 0) {\r\n      let dcVals: DcValues = this.getDcVals();\r\n      return dcVals.isNull(idx);\r\n    }\r\n    else {\r\n      return result;\r\n    }\r\n  }\r\n\r\n  /// <summary> Computes the control's value either from expression or field and refreshes the GUI </summary>\r\n  /// <param name=\"forceRefresh\"></param>\r\n  async ComputeAndRefreshDisplayValue(forceRefresh: boolean): Promise<void> {\r\n    if (forceRefresh) {\r\n      this.resetPrevVal();\r\n    }\r\n\r\n    if (this._valExpId > 0) {\r\n      let wasEvaluated: boolean;\r\n      let refWasEvaluated: RefParam<boolean> = new RefParam<boolean>(wasEvaluated);\r\n\r\n      let retExp: string =\r\n        await this.EvaluateExpression(this._valExpId, this.DataType, this._pic.getSize(), true, StorageAttribute.SKIP, false, refWasEvaluated);\r\n      wasEvaluated = refWasEvaluated.value;\r\n      if (wasEvaluated) {\r\n        await this.SetAndRefreshDisplayValue(retExp, retExp === null);\r\n      }\r\n    }\r\n    else {\r\n      if (this._field !== null) {\r\n        let value: string = NString.Empty;\r\n        let isNull: boolean = false;\r\n        let refValue: RefParam<string> = new RefParam<string>(value);\r\n        let refIsNull: RefParam<boolean> = new RefParam<boolean>(isNull);\r\n        (<GuiTaskBase>this._field.getTask()).getFieldDisplayValue(this._field, refValue, refIsNull);\r\n        value = refValue.value;\r\n        isNull = refIsNull.value;\r\n        await this.SetAndRefreshDisplayValue(value, isNull);\r\n      }\r\n      else {\r\n        if (!super.isTableControl() && !super.isColumnControl()) {\r\n          await this.RefreshDisplayValue(this.Value);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Decides if the control should be refreshed while entering a control. Values for some data types\r\n  /// are displayed differently while parked on the control.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  ShouldRefreshOnControlEnter(): boolean {\r\n    return this.Type === MgControlType.CTRL_TYPE_TEXT && this.getField() !== null && (this.getField().getType() === StorageAttribute.DATE ||\r\n      this.getField().getType() === StorageAttribute.TIME || this.getField().getType() === StorageAttribute.NUMERIC);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   refresh the displayed value only (without the other properties of the control)\r\n  /// </summary>\r\n  /// <param name = \"mgVal\">is the magic internal value of the presentation value</param>\r\n  async RefreshDisplayValue(mgVal: string): Promise<void> {\r\n    let line: number = this.getDisplayLine(true);\r\n    let valueChanged: boolean = true;\r\n    let saveValueChanged: boolean = valueChanged;\r\n\r\n    if (line < 0) {\r\n      line = 0;\r\n    }\r\n    // ATTENTION:\r\n    // the use of the function getName() instead of using the name member variable\r\n    // is to enhance the use of controls which are contained in a table\r\n    // update the display\r\n    try {\r\n\r\n      let prevValue: string = this._prevValues.get_Item(line);\r\n      let prevNull: boolean = this.getPrevIsNull();\r\n\r\n      if (StorageAttributeCheck.IsTypeAlphaOrUnicode(this.DataType)) {\r\n        if (StrUtil.rtrim(mgVal) === StrUtil.rtrim(prevValue) ||\r\n          (mgVal !== null && StrUtil.rtrim(mgVal) === StrUtil.rtrim(prevValue))) {\r\n          valueChanged = false;\r\n        }\r\n\r\n        if (prevNull !== this.IsNull) {\r\n          valueChanged = true;\r\n        }\r\n      }\r\n      else {\r\n        ;\r\n        if (mgVal === prevValue || (mgVal !== null && mgVal === prevValue))\r\n          valueChanged = false;\r\n\r\n        if (prevNull !== this.IsNull)\r\n          valueChanged = true;\r\n\r\n      }\r\n      this._prevValues.set_Item(line, mgVal);\r\n      this.setPrevIsNull(this.IsNull);\r\n\r\n      switch (this.Type) {\r\n        case MgControlType.CTRL_TYPE_TABLE:\r\n        case MgControlType.CTRL_TYPE_COLUMN:\r\n        case MgControlType.CTRL_TYPE_LABEL:\r\n        case MgControlType.CTRL_TYPE_SUBFORM:\r\n        case MgControlType.CTRL_TYPE_GROUP:\r\n        case MgControlType.CTRL_TYPE_STATUS_BAR:\r\n        case MgControlType.CTRL_TYPE_FRAME_SET:\r\n        case MgControlType.CTRL_TYPE_CONTAINER:\r\n        case MgControlType.CTRL_TYPE_FRAME_FORM:\r\n        case MgControlType.CTRL_TYPE_SB_LABEL:\r\n        case MgControlType.CTRL_TYPE_LINE:\r\n          return;\r\n\r\n        case MgControlType.CTRL_TYPE_BROWSER:\r\n          if (valueChanged && this.Value != null)\r\n            this.setUrl();\r\n          return;\r\n\r\n        case MgControlType.CTRL_TYPE_IMAGE:\r\n        case MgControlType.CTRL_TYPE_SB_IMAGE:\r\n          if (valueChanged && this.Value != null)\r\n            this.setImage();\r\n          return;\r\n\r\n        case MgControlType.CTRL_TYPE_CHECKBOX:\r\n          if (valueChanged ||  this.forceRefresh)\r\n            this.setCheckBoxValue(line, mgVal);\r\n          return;\r\n\r\n        case MgControlType.CTRL_TYPE_TAB:\r\n        case MgControlType.CTRL_TYPE_COMBO:\r\n        case MgControlType.CTRL_TYPE_LIST:\r\n          saveValueChanged = valueChanged;\r\n          valueChanged = await this.refreshAndSetItemListByDataSource(line, valueChanged);\r\n          if (valueChanged) {\r\n            // fixed bug#:776215, 800763,941841, the prevValue is save as mgval need to convert to layer\r\n            let prevDisplayValue: number[] = null;\r\n\r\n            // Fix bug#:784391\r\n            // If ItemList was update refreshAndSetItemListByDataSource then the value must be set\r\n\r\n            if (saveValueChanged === valueChanged) {\r\n              if (prevValue !== null) {\r\n                prevDisplayValue = this.getLayerFromLinkIdx(await this.getIndexOfChoice(prevValue, line, prevNull));\r\n                for (let i: number = 0; i < prevDisplayValue.length; i = i + 1) {\r\n                  if (prevDisplayValue[i] === GuiConstants.DEFAULT_VALUE_INT) {\r\n                    prevDisplayValue[i] = GuiConstants.DEFAULT_LIST_VALUE;\r\n                  }\r\n                }\r\n              }\r\n            }\r\n            let indice = Misc.GetIntArray(this.Value);\r\n\r\n            if (this.isTabControl()) {\r\n              let currentLayer = this.getCurrentLinkIdx();\r\n              Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.SelectedValue, indice[0].toString());\r\n              Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.SelectedLayer, currentLayer.toString());\r\n            }\r\n\r\n            if (this.IsMultipleSelectionListBox()) {\r\n              Commands.addValueWithLine(CommandType.SET_VALUE, this, line, indice);\r\n            }\r\n            else\r\n              Commands.addValueWithLine(CommandType.SET_VALUE, this, line, +this.Value);\r\n          }\r\n          break;\r\n\r\n        case MgControlType.CTRL_TYPE_BUTTON:\r\n        case MgControlType.CTRL_TYPE_TEXT:\r\n          if (this.HasAutocomplete())\r\n            await this.refreshAndSetItemListByDataSource(line, valueChanged);\r\n          if (valueChanged) {\r\n            // if (form.formRefreshed() || forceRefresh || valExp != null &&\r\n            // valExp.computedByClientOnly())\r\n            if (this.IsImageButton()) {\r\n              this.setImageWithFileName(this.Value);\r\n            }\r\n            else\r\n              this.setText();\r\n          }\r\n          else\r\n            return;\r\n          break;\r\n\r\n        case MgControlType.CTRL_TYPE_RADIO:\r\n          valueChanged = await this.refreshAndSetItemListByDataSource(line, valueChanged);\r\n          if (!valueChanged)\r\n            return;\r\n          this.setRadioChecked(this.Value);\r\n          // setRadioChecked(value .length() == 0 ? DEFAULT_VALUE_INT : Integer.parseInt(value));\r\n          // if (!task.startProcess())\r\n          // guiManager.setFocus(this);\r\n          break;\r\n\r\n        default:\r\n          Events.WriteExceptionToLog(NString.Format(\"in Control.RefreshDisplayValue() unknown type: {0}\", this.Type));\r\n          return;\r\n      }\r\n\r\n      if (super.isChoiceControl() && valueChanged)\r\n        await this.updatePropertyLogicNesting(PropInterface.PROP_TYPE_VISIBLE, CommandType.PROP_SET_VISIBLE, await this.checkProp(PropInterface.PROP_TYPE_VISIBLE, true), false);\r\n    } catch (ex_360) {\r\n      if (ex_360 instanceof Exception) {\r\n        Events.WriteExceptionToLog(NString.Format(\"in Control.RefreshDisplayValue() for control: {0}\", this.Name));\r\n      }\r\n      else\r\n        throw ex_360;\r\n    }\r\n  }\r\n\r\n  async RefreshDisplay(onlyRepeatableProps?: boolean): Promise<void> {\r\n    if (isNullOrUndefined(onlyRepeatableProps))\r\n      onlyRepeatableProps = false;\r\n    await this.RefreshDisplay_1(onlyRepeatableProps);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   updates the display of the control including its value and its properties\r\n  /// </summary>\r\n  /// <param name = \"onlyRepeatableProps\">if control tree - refreshes only repeatable tree properties</param>\r\n  private async RefreshDisplay_1(onlyRepeatableProps: boolean): Promise<void> {\r\n\r\n    // #422250. Skip the refresh display of the parent's subform control if the form inside it is still in its RefreshDisplay.\r\n    if (!(super.isSubform() && this.GetSubformMgForm() !== null && this.GetSubformMgForm().inRefreshDisplay())) {\r\n\r\n      // update the properties\r\n      await this.refreshProperties(onlyRepeatableProps);\r\n\r\n      // compute and display the value.\r\n      if (this.ShouldComputeAndRefreshOnClosedForm()) {\r\n        await this.ComputeAndRefreshDisplayValue(false);\r\n      }\r\n\r\n      // executes the readonly command only if needed\r\n      let isParkableCtrl: boolean = !(await this.isParkable(false)) || ! await this.isModifiable();\r\n\r\n      if (this.GetCurrReadOnly() !== isParkableCtrl) {\r\n        this.SetCurrReadOnly(isParkableCtrl);\r\n        await Manager.SetReadOnlyControl(this, isParkableCtrl);\r\n      }\r\n\r\n      let mustInputProperty: Property = this.GetComputedProperty(PropInterface.PROP_TYPE_MUST_INPUT);\r\n      // need to compute and refresh the display if the control's data is an expression\r\n      // or the format is expression. When the format is changed, the display val may change as well.\r\n      if (mustInputProperty != null && mustInputProperty.isExpression()) {\r\n\r\n        let prevMustInput: boolean = this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MUST_INPUT, false);\r\n\r\n        if (prevMustInput !== await this.checkProp(PropInterface.PROP_TYPE_MUST_INPUT, false))\r\n          Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.MustInput, !prevMustInput);\r\n      }\r\n\r\n      if (!this.GetComputedBooleanProperty(PropInterface.PROP_TYPE_TAB_IN, true))\r\n        Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, this.getDisplayLine(false), HtmlProperties.TabIndex, -1);\r\n\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// For Rich Client compute and refresh the value of the control always, also if the form is not yet opened.\r\n  /// For Online only for opened forms.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  ShouldComputeAndRefreshOnClosedForm(): boolean {\r\n    return true;\r\n  }\r\n\r\n  /// <summary> Refreshes the properties of the control. </summary>\r\n  /// <param name=\"onlyRepeatableProps\"></param>\r\n  async refreshProperties(onlyRepeatableProps: boolean): Promise<void> {\r\n\r\n    if (this._field !== null && this.DataType !== StorageAttribute.NONE && this._firstRefreshProperties)\r\n      Commands.addWithNumber(CommandType.SET_ATTRIBUTE, this, this.DataType.charCodeAt(0));\r\n\r\n    if (this._propTab !== null) {\r\n      try {\r\n\r\n        if (this._firstRefreshProperties) {\r\n            this.createDefaultProps();\r\n            await this.ZoomButtonInitialization();\r\n        }\r\n\r\n        if (!(await this._propTab.RefreshDisplay(false, onlyRepeatableProps))) {\r\n          Events.WriteExceptionToLog(NString.Format(\"Control '{0}': Not all properties could be set\", this.getName()));\r\n        }\r\n\r\n        if (this._firstRefreshProperties) {\r\n          if (!onlyRepeatableProps) {\r\n            this._firstRefreshProperties = false;\r\n          }\r\n        }\r\n      } catch (ex) {\r\n        if (ex instanceof Exception) {\r\n          let msg: StringBuilder = new StringBuilder(NString.Format(\"Control '{0}': {1}\", this.getName(), ex.Message));\r\n          Events.WriteExceptionToLog(msg.ToString());\r\n        }\r\n        else\r\n          throw ex;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  async refreshTabForLayerList(line: number): Promise<void> {\r\n    let currentLinkValue: string = null;\r\n\r\n    // If the form has already opened, get the current link value before\r\n    // changing the layer list i.e. before calling refreshAndSetItemsList().\r\n    // And then, after changing the layer list, select the TAB corresponding\r\n    // to the current link value.\r\n    if (this.getForm().Opened) {\r\n      let indice: number[] = this.getCurrentIndexOfChoice();\r\n      let currentLayer: number = indice[0];\r\n      currentLinkValue = await this.getLinkValue(currentLayer.toString(), line);\r\n    }\r\n    await this.refreshAndSetItemsList(line, false);\r\n    if (this.getForm().Opened) {\r\n      await this.SetAndRefreshDisplayValue(currentLinkValue, this.IsNull);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   refresh the item list of radio button\r\n  /// </summary>\r\n  /// <param name=\"line\">Display line</param>\r\n  /// <param name=\"execComputeChoice\"></param>\r\n  async refreshAndSetItemsListForRadioButton(line: number, execComputeChoice: boolean): Promise<void> {\r\n\r\n    // 1. create the button for each items list\r\n    let displayList: string[] = await this.refreshDispRange(execComputeChoice);\r\n\r\n    let options = displayList.map((displayValue, counter) => {\r\n      let index: string = counter.toString();\r\n      return {index, displayValue}\r\n    });\r\n    // creates new radio buttons from display list.\r\n\r\n    Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.ItemsList, options);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   refresh the item list and set it into the gui control if it is combo box , refresh also the visible\r\n  ///   lines\r\n  /// </summary>\r\n  async refreshAndSetItemsList(line: number, execComputeChoice: boolean): Promise<void> {\r\n    if (execComputeChoice) {\r\n      this.clearRange(line);\r\n    }\r\n    let optionsStrings: string[] = await this.refreshDispRange(execComputeChoice);\r\n    if (super.isSelectionCtrl() || super.isTabControl() || this.HasAutocomplete()) {\r\n\r\n      let options = optionsStrings.map((displayValue, index) => {\r\n        return {index, displayValue}\r\n      });\r\n\r\n      Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, line, HtmlProperties.ItemsList, options);\r\n\r\n    }\r\n    else {\r\n      if (super.isRadio()) {\r\n        await this.refreshAndSetItemsListForRadioButton(line, execComputeChoice);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   refresh the choice list of a SELECT control\r\n  /// </summary>\r\n  async refreshDispRange(execComputeChoice: boolean): Promise<string[]> {\r\n    let selectCmd: string[] = new Array<string>(0);\r\n    let line: number = this.getDisplayLine(true);\r\n\r\n    if (line < 0) {\r\n      line = 0;\r\n    }\r\n    if (this.SupportsDataSource()) {\r\n      let dataView: GuiDataViewBase = this.getForm().getTask().DataView;\r\n      let dcv: DcValues = dataView.getDcValues(this._dcValId);\r\n      let dispVals: string[] = await this.getDispVals(line, execComputeChoice);\r\n\r\n      if (this._hasValidItmAndDispVal) {\r\n        selectCmd = MgControlBase.combineStringArrays(dispVals, dcv.getDispVals());\r\n      }\r\n    }\r\n    else {\r\n      selectCmd = await this.getDispVals(line, execComputeChoice);\r\n    }\r\n    this._rangeChanged = true;\r\n    return await this.getOrderedDispList(selectCmd, line);\r\n  }\r\n\r\n  /// <summary>\r\n  /// refresh the items list of the selection control.\r\n  /// </summary>\r\n  /// <param name=\"execComputeChoice\"></param>\r\n  /// <returns></returns>\r\n  async refreshItmRange(execComputeChoice: boolean): Promise<string[]> {\r\n\r\n    // This function should be called only for selection control.\r\n    Debug.Assert(this.SupportsDataSource());\r\n    let orderedItmList: string[] = new Array<string>(0);\r\n    let line: number = this.getDisplayLine(false);\r\n    if (line < 0) {\r\n      line = 0;\r\n    }\r\n    if (execComputeChoice) {\r\n      await this.computeChoice(line);\r\n    }\r\n    let linkVals: string[] = this._choiceLinks.get_Item(line);\r\n    let dataView: GuiDataViewBase = this.getForm().getTask().DataView;\r\n    let dcv: DcValues = dataView.getDcValues(this._dcValId);\r\n    if (this._hasValidItmAndDispVal) {\r\n      orderedItmList = MgControlBase.combineStringArrays(linkVals, dcv.GetLinkVals());\r\n    }\r\n\r\n    return await this.getOrderedDispList(orderedItmList, line);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the items values from data source & item list property.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  async GetItemsRange(): Promise<string[]> {\r\n    return await this.refreshItmRange(false);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the display values from data source & display list property.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  async GetDisplayRange(): Promise<string[]> {\r\n    return await this.refreshDispRange(false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private createDefaultProps() {\r\n    this.getProp(PropInterface.PROP_TYPE_VISIBLE);\r\n\r\n    // Fixed bug#:781741\r\n    // in 1.9 -->\r\n    // when ask about any property(PROP_TYPE_ENABLED) we was created the default property with the default value(true).\r\n    // and when get to RefreshProps of the property \"PROP_TYPE_ENABLED\" we was add command to the queue in gui thread\r\n    // the command was was update the TagData.Enable to be \"true\"\r\n    // in 2.0 -->\r\n    // we useing a new method GetComputedBooleanProperty() that not created any default property and no get to refreshProp\r\n    // on the property and the value on the Control.Enable was wrong\r\n    this.getProp(PropInterface.PROP_TYPE_ENABLED);\r\n\r\n    if (super.isTableControl()) {\r\n      this.getProp(PropInterface.PROP_TYPE_SCROLL_BAR);\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   set Linked Parent Idx\r\n  /// </summary>\r\n  /// <param name=\"linkedParentDitIdx\"></param>\r\n  private setLinkedParentIdx(linkedParentDitIdx: number): void {\r\n    this._linkedParentDitIdx = linkedParentDitIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the validation details of the control\r\n  /// </summary>\r\n  /// <param name=\"oldVal\"></param>\r\n  /// <param name=\"val\"></param>\r\n  /// <returns></returns>\r\n  buildPicture(oldVal: any, val: any): ValidationDetails {\r\n\r\n    if (super.isTableControl() || super.isColumnControl())\r\n      return null;\r\n\r\n    if (this._picExpExists) {\r\n      this._vd = null;\r\n    }\r\n    if (this._vd === null) {\r\n      this._vd = new ValidationDetails(oldVal, val, this._range, this._pic, this);\r\n    }\r\n    else {\r\n      this._vd.setValue(val);\r\n      this._vd.setOldValue(oldVal);\r\n    }\r\n\r\n    return this._vd;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Checks if the sent value is different than the control's existing value.\r\n  /// </summary>\r\n  /// <param name = \"NewValue\"></param>\r\n  /// <param name=\"isNull\"></param>\r\n  /// <param name=\"checkNullValue\"></param>\r\n  /// <returns></returns>\r\n  isDifferentValue(newValue: any, isNull: boolean, checkNullValue: boolean): boolean {\r\n\r\n    let ctrlCurrValue: any = this.Value;\r\n    let valChanged: boolean = false;\r\n\r\n    if (newValue instanceof Date) {\r\n      if (this.DataType === StorageAttribute.DATE)\r\n        valChanged = !this.CompareDate(newValue, ctrlCurrValue);\r\n      else\r\n        valChanged = !this.CompareTime(newValue, ctrlCurrValue);\r\n    }\r\n\r\n    if (typeof newValue === 'boolean' || typeof newValue === 'number') {\r\n      if (this.isSelectionCtrl() && typeof ctrlCurrValue === 'string') {\r\n        let newValuestr = newValue.toString();\r\n        valChanged = (newValuestr !== ctrlCurrValue);\r\n      }\r\n      else {\r\n        valChanged = (newValue !== ctrlCurrValue);\r\n      }\r\n    }\r\n    else {\r\n      if (this.isSelectionCtrl() && typeof ctrlCurrValue === 'string' && Array.isArray(newValue)) {\r\n        let newValueStr = newValue.join(',').toString();\r\n        valChanged = !(StrUtil.rtrim(newValueStr) === StrUtil.rtrim(ctrlCurrValue));\r\n      }\r\n      else {\r\n        let ctrlCurrIsNull: boolean = this.IsNull;\r\n        valChanged = !(StrUtil.rtrim(newValue) === StrUtil.rtrim(ctrlCurrValue));\r\n        if (!valChanged && checkNullValue) {\r\n          valChanged = (isNull !== ctrlCurrIsNull);\r\n        }\r\n      }\r\n    }\r\n    return valChanged;\r\n  }\r\n\r\n  CompareDate(d1: Date, d2: Date): boolean {\r\n    let retval: boolean;\r\n    if (d1 === null && d2 === null)\r\n      retval = true;\r\n    else if ((d1 === null && d2 !== null) || (d1 !== null && d2 === null))\r\n      retval = false;\r\n    else if (d1.getFullYear() === d2.getFullYear()\r\n      && d1.getDate() === d2.getDate()\r\n      && d1.getMonth() === d2.getMonth())\r\n      retval = true;\r\n    return retval;\r\n  }\r\n\r\n  CompareTime(d1: Date, d2: Date): boolean {\r\n    let retval: boolean;\r\n    if (d1 === null && d2 === null)\r\n      retval = true;\r\n    else if ((d1 === null && d2 !== null) || (d1 !== null && d2 === null))\r\n      retval = false;\r\n    else if (d1.getHours() === d2.getHours()\r\n      && d1.getMinutes() === d2.getMinutes()\r\n      && d1.getSeconds() === d2.getSeconds())\r\n      retval = true;\r\n    return retval;\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if column's sortable property is set to true\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isColumnSortable(): boolean {\r\n    let isSortable: boolean = false;\r\n\r\n    if (this.Type === MgControlType.CTRL_TYPE_COLUMN && this._propTab.propExists(PropInterface.PROP_TYPE_SORT_COLUMN)) {\r\n      isSortable = this.GetComputedProperty(PropInterface.PROP_TYPE_SORT_COLUMN).GetComputedValueBoolean();\r\n    }\r\n\r\n    return isSortable;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns first child MgControl of column i.e. field attached to column\r\n  /// </summary>\r\n  /// <returns></returns>\r\n\r\n  getColumnChildControl(): MgControlBase {\r\n    if (this.Type !== MgControlType.CTRL_TYPE_COLUMN)\r\n      return null;\r\n\r\n    let linkedControls: List<MgControlBase> = this._parentTable.getLinkedControls();\r\n\r\n    return linkedControls.find((control: MgControlBase) => (control.getLayer() === this.getLayer() && control.Type !== MgControlType.CTRL_TYPE_COLUMN && !control.IsTableHeaderChild));\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get control name for handler search propose.\r\n  ///   The control itself, may not have a name for handler search (like column control, in which we need to use\r\n  ///   the child control name for handlers search)\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getControlNameForHandlerSearch(): string {\r\n    let childControl: MgControlBase = this.getColumnChildControl();\r\n    let name: string;\r\n    if (childControl !== null) {\r\n      return childControl.Name;\r\n    }\r\n    else\r\n      return this.Name;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add a control to the list of linked controls\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  linkCtrl(ctrl: MgControlBase): void {\r\n    this._linkedControls.push(ctrl);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   removes the reference to this control from the field\r\n  /// </summary>\r\n  removeRefFromField(): void {\r\n    if (this._field !== null) {\r\n      this._field.RemoveControl(this);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the dit index of the control\r\n  /// </summary>\r\n  getDitIdx(): number {\r\n    return this._ditIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  /// sets dcValId\r\n  /// </summary>\r\n  /// <param name=\"dcValId\"></param>\r\n  setDcValId(dcValId: number): void {\r\n    this._dcValId = dcValId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   if the picture define as hebrew then set the lang to hebrew, otherwise restore the lang\r\n  ///   The same we doing for online :edt_edit.cpp : SetKeyboardLanguage()\r\n  /// </summary>\r\n  /// <param name = \"restoreLang\"></param>\r\n  SetKeyboardLanguage(): void {\r\n    Commands.beginInvoke();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Initialize control properties for derived class\r\n  /// </summary>\r\n  Init(): void {\r\n  }\r\n\r\n  /// <summary>(internal)\r\n  /// checks if control is parkable\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  async IsParkable(): Promise<boolean> {\r\n    return await this.isParkable(true);\r\n  }\r\n\r\n  /// <summary>(internal)\r\n  /// checks if control has expression or Parent task field\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  HasExpOrParentTaskField(): boolean {\r\n    let task: GuiTaskBase = this.getForm().getTask();\r\n    return (this.getField() === null || this.getField().getTask() !== task);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the control is parkable\r\n  /// </summary>\r\n  /// <param name = \"checkEnabledAndVisible\">check enabled and visible properties too</param>\r\n  async isParkable(checkEnabledAndVisible: boolean): Promise<boolean> {\r\n\r\n    let result: boolean;\r\n    result = !super.isTableControl() && !super.isColumnControl();\r\n\r\n    let task: GuiTaskBase = this.getForm().getTask();\r\n    // non interactive -> not parkable.\r\n    if (result) {\r\n      result = task.IsInteractive;\r\n    }\r\n\r\n    if (result && task.DataView.isEmptyDataview() && this._field !== null && this._field.PartOfDataview) {\r\n      result = false;\r\n    }\r\n    if (result) {\r\n      // QCR #441177. When we check the subform park ability, we need to check also it's visibility and enable properties.\r\n      if (!super.isSubform()) {\r\n          result = ((this._field !== null && this._field.getTask() === task) || this.isButton() || super.isBrowserControl());\r\n      }\r\n      if (result && checkEnabledAndVisible) {\r\n        result = (this.isEnabled() && this.isVisible());\r\n      }\r\n\r\n      if ((result && this._parentTable !== null) && checkEnabledAndVisible) {\r\n        result = (this._parentTable.GetComputedBooleanProperty(PropInterface.PROP_TYPE_ENABLED, true) && this._parentTable.GetComputedBooleanProperty(PropInterface.PROP_TYPE_VISIBLE, true));\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Raise ACT_CTRL_HIT on left mouse click if it meets following condition.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  RaiseControlHitOnLeftClickOfMouseDown(): boolean {\r\n    let raiseCtrlHit: boolean = false;\r\n    if (!super.IsHyperTextButton() && !super.isRadio() && !super.isTabControl()) {\r\n      raiseCtrlHit = true;\r\n    }\r\n    return raiseCtrlHit;\r\n  }\r\n\r\n  GetVarIndex(): number {\r\n    return 0;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Returns true if the 'Control Hit' event should be raised on mouse down.\r\n  /// The method was extracted from processMouseDown, since we might have different\r\n  /// behaviors for different types of tree controls.\r\n  /// </summary>\r\n  /// <param name=\"leftClickWasPressed\"></param>\r\n  /// <returns></returns>\r\n  RaiseControlHitOnMouseDown(leftClickWasPressed: boolean): boolean {\r\n    let raiseCtrlHit: boolean = false;\r\n    if (leftClickWasPressed) {\r\n      if (this.RaiseControlHitOnLeftClickOfMouseDown()) {\r\n        raiseCtrlHit = true;\r\n      }\r\n    }\r\n    return raiseCtrlHit;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Handle MG_ACT_HIT on the subform control\r\n  /// </summary>\r\n  OnSubformClick(): void {\r\n    Manager.EventsManager.addGuiTriggeredEventWithTaskAndCode(this.getForm().getTask(), InternalInterface.MG_ACT_HIT);\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns MgForm of the subform control task\r\n  /// </summary>\r\n  GetSubformMgForm(): MgFormBase {\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"id\"></param>\r\n  /// <returns></returns>\r\n  PropertyExists(id: number): boolean {\r\n    return this._propTab.propExists(id);\r\n  }\r\n\r\n  toString(): string {\r\n    return \"{\" + this.constructor.name + \": \" + MgControlType[this.Type] + \"}\";\r\n  }\r\n\r\n  /// <summary> Checks if new date is 0</summary>\r\n  /// <param name=\"value\"> The value to check</param>\r\n  isDateZero(val: Date) {\r\n    let zeroDate: boolean = false;\r\n    if (val instanceof Date) {\r\n      if (val.getMonth() === 0 && val.getFullYear() === 0 && val.getDay() === 0)\r\n        zeroDate = true;\r\n    }\r\n    return zeroDate;\r\n  }\r\n\r\n  IsDefaultRouterOutlet(): boolean {\r\n    return (this.Type === MgControlType.CTRL_TYPE_SUBFORM && this.GetComputedBooleanProperty_0(PropInterface.PROP_TYPE_DEFAULT_OUTLET, false));\r\n  }\r\n\r\n  IsRouterOutlet(): boolean {\r\n    return (this.Type === MgControlType.CTRL_TYPE_SUBFORM && this.GetComputedBooleanProperty_0(PropInterface.PROP_TYPE_IS_ROUTER_OUTLET, false));\r\n  }\r\n\r\n  async ZoomButtonInitialization(): Promise<void> {\r\n    if (this.isTextControl() && this.checkIfExistProp(PropInterface.PROP_TYPE_CONNECTED_ZOOM_CONTROL))\r\n    {\r\n      let connectedButton: MgControlBase = this.Form.CtrlTab.GetControlByIsn((await (await this.getProp(PropInterface.PROP_TYPE_CONNECTED_ZOOM_CONTROL)).getValueInt()));\r\n\r\n      // image button - calculate according to image\r\n      let imageFileName : string  = null;\r\n      if (connectedButton.IsImageButton() && connectedButton.PropertyExists(PropInterface.PROP_TYPE_IMAGE_FILENAME))\r\n      {\r\n        imageFileName = await(await connectedButton.getProp(PropInterface.PROP_TYPE_IMAGE_FILENAME)).getValue();\r\n        if (!Misc.IsWebUrl(imageFileName))\r\n          imageFileName = \"./assets/images/\" + imageFileName;\r\n         Commands.addOperationWithLine(CommandType.SET_STYLE, this, 0, MagicProperties.ImageFile, imageFileName);\r\n\r\n      }\r\n\r\n      // store the edit control on the button\r\n      this.ConnectedControl = connectedButton;\r\n      connectedButton.ConnectedControl = this;\r\n    }\r\n  }\r\n}\r\n"]}