@magic-xpa/engine 4.1100.0-dev4110.106 → 4.1100.0-dev4110.107

package/esm2020/src/gui/FormsTable.mjs

@@ -0,0 +1,66 @@
+import { List } from "@magic-xpa/mscorelib";
+import { XMLConstants } from "@magic-xpa/utils";
+import { Manager, RuntimeContextBase } from "@magic-xpa/gui";
+import { RemoteTaskService } from "../tasks/RemoteTaskService";
+export class FormsTable {
+    get Count() {
+        return this._formsStringXml.length;
+    }
+    get_Item(formDisplayIndex) {
+        if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)
+            return this._formsStringXml.get_Item(formDisplayIndex - 1);
+        return null;
+    }
+    constructor(task, parentForm) {
+        this._task = null;
+        this._parentForm = null;
+        this._formsStringXml = null;
+        this._task = task;
+        this._parentForm = parentForm;
+    }
+    async fillData() {
+        this._formsStringXml = new List();
+        let parser = Manager.GetCurrentRuntimeContext().Parser;
+        while (await this.initInnerObjects(parser.getNextTag())) {
+        }
+    }
+    InitFormFromXmlString(formDisplayIndex) {
+        let formStrXml = this.get_Item(1);
+        if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)
+            formStrXml = this.get_Item(formDisplayIndex);
+        if (formStrXml !== null) {
+            RuntimeContextBase.Instance.Parser.push();
+            RuntimeContextBase.Instance.Parser.PrepareFormReadString(formStrXml);
+            this._task.FormInitData(this._parentForm);
+            RuntimeContextBase.Instance.Parser.pop();
+        }
+    }
+    async initInnerObjects(foundTagName) {
+        if (foundTagName === null)
+            return false;
+        let parser = Manager.GetCurrentRuntimeContext().Parser;
+        if (foundTagName === XMLConstants.MG_TAG_FORMS) {
+            parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+        }
+        else if (foundTagName === XMLConstants.MG_TAG_FORM) {
+            let formStringXml = RuntimeContextBase.Instance.Parser.ReadToEndOfCurrentElement();
+            this._formsStringXml.push(formStringXml);
+            return true;
+        }
+        else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORM)) {
+            parser.setCurrIndex2EndOfTag();
+            return true;
+        }
+        else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORMS)) {
+            await this.PrepareMainDisplayForConnectedTask();
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        return true;
+    }
+    async PrepareMainDisplayForConnectedTask() {
+        if (this._task.TaskService instanceof RemoteTaskService)
+            await this._task.PrepareTaskForm();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FormsTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/gui/FormsTable.ts"],"names":[],"mappings":"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","sourcesContent":["import {List} from \"@magic-xpa/mscorelib\";\r\nimport {XmlParser, XMLConstants} from \"@magic-xpa/utils\";\r\nimport {Manager, MgFormBase, RuntimeContextBase} from \"@magic-xpa/gui\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {RemoteTaskService} from \"../tasks/RemoteTaskService\";\r\n\r\n/// <summary>\r\n/// save all forms on task\r\n/// </summary>\r\nexport class FormsTable {\r\n  private _task: Task = null;\r\n  private _parentForm: MgFormBase = null;\r\n  _formsStringXml: List<string> = null;\r\n\r\n  /// <summary>\r\n  /// count of forms\r\n  /// </summary>\r\n  get Count(): number {\r\n    return this._formsStringXml.length;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the form by send the display index\r\n  /// </summary>\r\n  /// <param name=\"formDisplayIndex\"></param>\r\n  /// <returns></returns>\r\n  get_Item(formDisplayIndex: number): string {\r\n    if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)\r\n      return this._formsStringXml.get_Item(formDisplayIndex - 1);\r\n\r\n    return null;\r\n  }\r\n\r\n  constructor(task: Task, parentForm: MgFormBase) {\r\n    this._task = task;\r\n    this._parentForm = parentForm;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the form structure\r\n  /// </summary>\r\n  /// <param name = \"taskRef\">reference to the ownerTask of this form</param>\r\n  async fillData(): Promise<void> {\r\n    this._formsStringXml = new List();\r\n\r\n    let parser: XmlParser = Manager.GetCurrentRuntimeContext().Parser;\r\n\r\n    while (await this.initInnerObjects(parser.getNextTag())) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// init the form of the task\r\n  /// </summary>\r\n  /// <param name=\"formDisplayIndex\"></param>\r\n  InitFormFromXmlString(formDisplayIndex: number): void {\r\n    // while the form isn't exist the first form will be open. (it is the same in non offline task)\r\n    let formStrXml: string = this.get_Item(1);\r\n\r\n    if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)\r\n      formStrXml = this.get_Item(formDisplayIndex);\r\n\r\n    if (formStrXml !== null) {\r\n      RuntimeContextBase.Instance.Parser.push(); // allow recursive parsing\r\n      RuntimeContextBase.Instance.Parser.PrepareFormReadString(formStrXml);\r\n\r\n      this._task.FormInitData(this._parentForm);\r\n      RuntimeContextBase.Instance.Parser.pop();\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\"></param>\r\n  /// <returns></returns>\r\n  private async initInnerObjects(foundTagName: string): Promise<boolean> {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    let parser: XmlParser = Manager.GetCurrentRuntimeContext().Parser;\r\n    if (foundTagName === XMLConstants.MG_TAG_FORMS) {\r\n      parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1); // move Index to end of <dvheader> +1 for '>'\r\n    }\r\n    else if (foundTagName === XMLConstants.MG_TAG_FORM) {\r\n      let formStringXml: string = RuntimeContextBase.Instance.Parser.ReadToEndOfCurrentElement();\r\n      this._formsStringXml.push(formStringXml);\r\n      return true;\r\n    }\r\n    else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORM)) {\r\n      parser.setCurrIndex2EndOfTag();\r\n      return true;\r\n    }\r\n    else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORMS)) {\r\n      await this.PrepareMainDisplayForConnectedTask();\r\n\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  /// for remote task we have all the information that we need to calculate the form display\r\n  /// </summary>\r\n  private async PrepareMainDisplayForConnectedTask(): Promise<void> {\r\n    if (this._task.TaskService instanceof RemoteTaskService)\r\n      await this._task.PrepareTaskForm();\r\n  }\r\n}\r\n"]}

package/esm2020/src/gui/MgControl.mjs

@@ -0,0 +1,353 @@
+import { Commands, CommandType, GuiDataCollection, HtmlProperties, MgControlBase, PropInterface } from '@magic-xpa/gui';
+import { InternalInterface, Logger, MgControlType, ScrollBarThumbType, StorageAttribute, SubformType, TableBehaviour } from '@magic-xpa/utils';
+import { Debug, NString } from '@magic-xpa/mscorelib';
+import { ArgumentsList } from '../rt/ArgumentsList';
+import { TaskBase } from '../tasks/TaskBase';
+import { ConstInterface } from '../ConstInterface';
+import { AccessHelper } from '../AccessHelper';
+export class MgControl extends MgControlBase {
+    initialize() {
+        this._focusedStopExecution = false;
+        this._inControlSuffix = false;
+        this._rtEvtTask = null;
+        this._subformTaskId = null;
+        this._subformTask = null;
+        this.IsInteractiveUpdate = false;
+        this.refreshOnString = null;
+        this.SubformLoaded = false;
+        this.HasZoomHandler = false;
+        this.ArgList = null;
+    }
+    constructor(type, taskOrParentMgForm, parentControlOrParentControlIdx) {
+        if (arguments.length === 0)
+            super();
+        else if (arguments.length === 3 && (type === null || type.constructor === Number) && (taskOrParentMgForm === null || taskOrParentMgForm instanceof TaskBase) && (parentControlOrParentControlIdx === null || parentControlOrParentControlIdx.constructor === Number))
+            super(type, taskOrParentMgForm.getForm(), parentControlOrParentControlIdx);
+        else
+            super(type, taskOrParentMgForm, parentControlOrParentControlIdx);
+        this.initialize();
+    }
+    GetVarIndex() {
+        return super.getForm().getTask().DataView.Dvcount + this.veeIndx;
+    }
+    async fillData(mgForm, ditIdx, parser) {
+        super.fillData(mgForm, ditIdx, parser);
+        this.ArgList = await this.GetArgumentList();
+    }
+    SetAttribute(attribute, valueStr) {
+        let isTagProcessed = super.SetAttribute(attribute, valueStr);
+        if (!isTagProcessed) {
+            switch (attribute) {
+                case ConstInterface.MG_ATTR_SUBFORM_TASK:
+                    if (valueStr.trim() != "")
+                        this._subformTaskId = valueStr;
+                    break;
+                case ConstInterface.MG_ATTR_REFRESHON:
+                    this.refreshOnString = valueStr.trim();
+                    break;
+                default:
+                    isTagProcessed = false;
+                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+                    break;
+            }
+        }
+        return isTagProcessed;
+    }
+    async GetArgumentList() {
+        let argList = null;
+        if (this._propTab === null)
+            return argList;
+        let ArgListProp = this._propTab.getPropById(PropInterface.PROP_TYPE_PARAMETERS);
+        if (ArgListProp === null)
+            return argList;
+        let parms = await ArgListProp.getValue();
+        if (parms !== null) {
+            argList = new ArgumentsList();
+            argList.fillList(parms, super.getForm().getTask());
+            if (this.refreshOnString !== null)
+                argList.RefreshOnString = this.refreshOnString;
+        }
+        return argList;
+    }
+    isDescendent(parentForm) {
+        let isDescendent = false;
+        let checkCurrentForm = super.getForm();
+        Debug.Assert(parentForm !== null);
+        while (!isDescendent && checkCurrentForm !== null) {
+            if (parentForm === checkCurrentForm)
+                isDescendent = true;
+            else {
+                let currTask = checkCurrentForm.getTask();
+                if (currTask.getParent() !== null)
+                    checkCurrentForm = currTask.getParent().getForm();
+                else
+                    break;
+            }
+        }
+        return isDescendent;
+    }
+    async refreshOnExpression() {
+        let i;
+        let size = (this._propTab === null ? 0 : this._propTab.getSize());
+        let prop;
+        let refresh = false;
+        for (i = 0; i < size && !refresh; i++) {
+            prop = this._propTab.getProp(i);
+            switch (prop.getID()) {
+                case PropInterface.PROP_TYPE_DATA:
+                    if (!prop.isExpression() && this._field !== null && this._field.getTask() !== this.getForm().getTask()) {
+                        refresh = true;
+                        break;
+                    }
+                case PropInterface.PROP_TYPE_FORMAT:
+                case PropInterface.PROP_TYPE_VISIBLE:
+                case PropInterface.PROP_TYPE_ENABLED:
+                case PropInterface.PROP_TYPE_RANGE:
+                case PropInterface.PROP_TYPE_TRANSLATOR:
+                    if (prop.isExpression())
+                        refresh = true;
+                    break;
+                default:
+                    break;
+            }
+            if (refresh)
+                await this.RefreshDisplay();
+        }
+    }
+    async invoke() {
+        let invoked = false;
+        if (await this.isParkable(true)) {
+            await AccessHelper.eventsManager.handleInternalEventWithMgControlBase(this, InternalInterface.MG_ACT_CTRL_PREFIX);
+            invoked = true;
+        }
+        return invoked;
+    }
+    async isParkable(checkEnabledAndVisible) {
+        let result = !super.isImageControl();
+        if (result) {
+            await super.checkProp(PropInterface.PROP_TYPE_ENABLED, true);
+            await super.checkProp(PropInterface.PROP_TYPE_VISIBLE, true);
+            result = await super.isParkable(checkEnabledAndVisible);
+        }
+        return result;
+    }
+    getSubformTaskId() {
+        return this._subformTaskId;
+    }
+    initSubformTask() {
+        if (super.isSubform())
+            this._subformTask = GuiDataCollection.MGDataTable.GetTaskByID(this._subformTaskId);
+    }
+    getParentTable() {
+        return this._parentTable;
+    }
+    async restoreOldValue() {
+        if (this._field !== null)
+            await this._field.updateDisplay();
+        else {
+            super.resetPrevVal();
+            await super.SetAndRefreshDisplayValue(await this.getMgValue(this.Value), this.IsNull);
+        }
+    }
+    setRtEvtTask(curTask) {
+        this._rtEvtTask = curTask;
+    }
+    getRtEvtTask() {
+        return this._rtEvtTask;
+    }
+    setSubformTaskId(taskId) {
+        this._subformTaskId = taskId;
+    }
+    isFocusedStopExecution() {
+        return this._focusedStopExecution;
+    }
+    setFocusedStopExecution(focusedStopExecution) {
+        this._focusedStopExecution = focusedStopExecution;
+    }
+    onTheSameSubFormControl(ctrl) {
+        let retValue = false;
+        if (ctrl !== null) {
+            if (super.getForm().isSubForm() && ctrl.getForm().isSubForm()) {
+                if (super.getForm().getTask() === ctrl.getForm().getTask())
+                    retValue = true;
+            }
+        }
+        return retValue;
+    }
+    onDiffForm(ctrl) {
+        let isSubform = super.getForm().isSubForm() || ctrl.getForm().isSubForm();
+        let isOnDiffForm = (isSubform) && !this.onTheSameSubFormControl(ctrl);
+        return isOnDiffForm;
+    }
+    isInControlSuffix() {
+        return this._inControlSuffix;
+    }
+    setInControlSuffix(inControlSuffix) {
+        this._inControlSuffix = inControlSuffix;
+    }
+    HasSelectProgram() {
+        let HasSelectProgram = false;
+        let selectProgProp = super.GetComputedProperty(PropInterface.PROP_TYPE_SELECT_PROGRAM);
+        if (selectProgProp !== null && selectProgProp.GetComputedValue() !== null)
+            HasSelectProgram = true;
+        return HasSelectProgram;
+    }
+    useZoomHandler() {
+        return this.HasZoomHandler || (super.getField() !== null && (super.getField().getHasZoomHandler() || (this.HasSelectProgram())));
+    }
+    async updatePropertyLogicNesting(propId, commandType, val, updateThis) {
+        if (val && super.haveToCheckParentValue())
+            val = super.isParentPropValue(propId);
+        if (val && super.isSubform() && commandType === CommandType.PROP_SET_VISIBLE && this.ShouldSetSubformInvisible())
+            val = false;
+        if (updateThis) {
+            Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, super.getDisplayLine(false), commandType === CommandType.PROP_SET_VISIBLE ? HtmlProperties.Visible : HtmlProperties.Enabled, val);
+        }
+        await super.updateChildrenPropValue(propId, commandType, val);
+    }
+    ShouldSetSubformInvisible() {
+        let setInvisible = false;
+        let subformType = super.GetComputedProperty(PropInterface.PROP_TYPE_SUBFORM_TYPE).GetComputedValueInteger();
+        if (subformType === SubformType.None && this.getSubformTaskId() === null)
+            setInvisible = true;
+        return setInvisible;
+    }
+    async updateSubformChildrenPropValue(propId, commandType, val) {
+        Debug.Assert(super.isSubform());
+        if (!super.getForm().getTask().AfterFirstRecordPrefix)
+            return;
+        let subformType = super.GetComputedProperty(PropInterface.PROP_TYPE_SUBFORM_TYPE).GetComputedValueInteger();
+        if (this._subformTaskId !== null || subformType === SubformType.None) {
+            if (this._subformTask !== null && this._subformTask.isStarted()) {
+                this.SubformLoaded = true;
+                if (commandType === CommandType.PROP_SET_VISIBLE && val && this.RefreshOnVisible) {
+                    this.RefreshOnVisible = false;
+                    await super.getForm().getTask().SubformRefresh(this._subformTask, true);
+                }
+                let subformForm = this._subformTask.getForm();
+                for (let i = 0; i < subformForm.getCtrlCount(); i++) {
+                    let child = subformForm.getCtrl(i);
+                    if (!child.isColumnControl())
+                        continue;
+                    let childValue = await child.checkProp(propId, true) && val;
+                    if (childValue)
+                        childValue = child.isParentPropValue(propId);
+                    await child.updateChildrenPropValue(propId, commandType, childValue);
+                }
+            }
+        }
+        else if ((commandType === CommandType.PROP_SET_VISIBLE && val) && !this.SubformLoaded) {
+            this.SubformLoaded = true;
+            await AccessHelper.eventsManager.handleInternalEventWithMgControlBase(this, InternalInterface.MG_ACT_SUBFORM_OPEN);
+        }
+    }
+    Init() {
+        this.initSubformTask();
+    }
+    GetTableBehaviour() {
+        return TableBehaviour.UnlimitedItems;
+    }
+    async validateAndSetValue(NewValue, updateCtrl) {
+        super.UpdateModifiedByUser(NewValue);
+        if (this.ModifiedByUser) {
+            let ctrlCurrValue = this.Value;
+            let vd;
+            if (super.getPIC() === null)
+                return true;
+            vd = super.buildPicture(ctrlCurrValue, NewValue);
+            vd.evaluate();
+            if (vd.ValidationFailed) {
+                this.ModifiedByUser = false;
+                return false;
+            }
+            this.IsInteractiveUpdate = true;
+            super.getForm().getTask().setDataSynced(false);
+            if (updateCtrl) {
+                if (this._field !== null && this._field.getType() === StorageAttribute.NUMERIC && typeof NewValue === 'string' && NewValue.trim().length > 0)
+                    vd.setValue(NewValue);
+                await this.setValue(vd);
+            }
+        }
+        return true;
+    }
+    async setValue(vd) {
+        let isNull = vd.getIsNull();
+        let newValue = vd.getDispValue();
+        let mgVal;
+        if (!isNull || !this._field.hasNullDisplayValue())
+            mgVal = await super.getMgValue(newValue);
+        else
+            mgVal = ((this._field.getType() === StorageAttribute.BLOB_VECTOR) ? this._field.getCellDefualtValue() : this._field.getDefaultValue());
+        if (mgVal !== null) {
+            if (this._field !== null && (!(newValue === this.Value) || this.KeyStrokeOn || this.IsNull !== isNull)) {
+                await this._field.setValueAndStartRecompute(mgVal, isNull, true, true, false);
+                if (super.isCheckBox()) {
+                    this.forceRefresh = true;
+                    mgVal = this._field.getValue(false);
+                }
+            }
+            if ((this._field !== null && isNull) && this._field.hasNullDisplayValue())
+                mgVal = newValue;
+            await super.SetAndRefreshDisplayValue(mgVal, isNull);
+            this.forceRefresh = false;
+            this.KeyStrokeOn = false;
+        }
+    }
+    getSubformTask() {
+        return this._subformTask;
+    }
+    resetSubformTask() {
+        this._subformTask = null;
+        this._subformTaskId = "0";
+    }
+    GetSubformMgForm() {
+        let form = null;
+        if (this._subformTask !== null)
+            form = this._subformTask.getForm();
+        return form;
+    }
+    IsTableWithAbsoluteScrollbar() {
+        let tableWithAbsoluteScrollbar = false;
+        Debug.Assert(this.Type === MgControlType.CTRL_TYPE_TABLE, "In MgControl.IsTableWithAbsoluteScrollbar(): Not a table control.");
+        if (this._propTab.propExists(PropInterface.PROP_TYPE_SCROLL_BAR_THUMB))
+            tableWithAbsoluteScrollbar = (this._propTab.getPropById(PropInterface.PROP_TYPE_SCROLL_BAR_THUMB).GetComputedValueInteger() === ScrollBarThumbType.Absolute);
+        return tableWithAbsoluteScrollbar;
+    }
+    static validReturnToCtrl() {
+        if (MgControl.ReturnToCtrl !== null && MgControl.ReturnToCtrl.getForm().getTask().isAborting())
+            return false;
+        return true;
+    }
+    maySetValue() {
+        switch (this.Type) {
+            case MgControlType.CTRL_TYPE_CHECKBOX:
+            case MgControlType.CTRL_TYPE_TEXT:
+            case MgControlType.CTRL_TYPE_COMBO:
+            case MgControlType.CTRL_TYPE_LIST:
+            case MgControlType.CTRL_TYPE_RADIO:
+            case MgControlType.CTRL_TYPE_TAB:
+                break;
+            default:
+                return false;
+        }
+        if (this._field === null || this._valExpId > 0)
+            return false;
+        return this.isModifiable();
+    }
+    async validateAndSetValueIfAllowed(NewValue, refreshDisplay) {
+        if (!this.maySetValue()) {
+            Logger.Instance.WriteErrorToLog(NString.Format("Unable to change value of control {0}: The control is read-only.", this.Name));
+            return false;
+        }
+        let retVal = await this.validateAndSetValue(NewValue, true);
+        if (!retVal)
+            Logger.Instance.WriteErrorToLog(NString.Format("Value validation failed for {0}.", this.Name));
+        if (refreshDisplay) {
+            Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());
+            Commands.invoke();
+        }
+        return retVal;
+    }
+}
+MgControl.ReturnToCtrl = null;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MgControl.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/gui/MgControl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,aAAa,EAGb,aAAa,EAGd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,MAAM,EACN,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,cAAc,EAEf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAC,KAAK,EAAE,OAAO,EAAC,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAC,QAAQ,EAAC,MAAM,mBAAmB,CAAC;AAI3C,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAQ7C,MAAM,OAAO,SAAU,SAAQ,aAAa;IAgBlC,UAAU;QAChB,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACnC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACjC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IASD,YAAY,IAAoB,EAAE,kBAAwB,EAAE,+BAAwC;QAClG,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;YACxB,KAAK,EAAE,CAAC;aACL,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,MAAM,CAAC,IAAI,CAAC,kBAAkB,KAAK,IAAI,IAAI,kBAAkB,YAAY,QAAQ,CAAC,IAAI,CAAC,+BAA+B,KAAK,IAAI,IAAI,+BAA+B,CAAC,WAAW,KAAK,MAAM,CAAC;YAClQ,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,OAAO,EAAE,EAAE,+BAA+B,CAAC,CAAC;;YAE3E,KAAK,CAAC,IAAI,EAAE,kBAAkB,EAAE,+BAA+B,CAAC,CAAC;QAEnE,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED,WAAW;QACT,OAAkB,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,QAAS,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC/E,CAAC;IAOD,KAAK,CAAC,QAAQ,CAAC,MAAkB,EAAE,MAAc,EAAE,MAAiB;QAClE,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;IAC9C,CAAC;IAKD,YAAY,CAAC,SAAiB,EAAE,QAAgB;QAC9C,IAAI,cAAc,GAAY,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACtE,IAAI,CAAC,cAAc,EAAE;YACnB,QAAQ,SAAS,EAAE;gBACjB,KAAK,cAAc,CAAC,oBAAoB;oBACtC,IAAI,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE;wBACvB,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;oBACjC,MAAM;gBACR,KAAK,cAAc,CAAC,iBAAiB;oBACnC,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;oBACvC,MAAM;gBACR;oBACE,cAAc,GAAG,KAAK,CAAC;oBACvB,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,OAAO,CAAC,MAAM,CAAC,+BAA+B,EAAE,SAAS,CAAC,CAAC,CAAC;oBACvG,MAAM;aACT;SACF;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAKO,KAAK,CAAC,eAAe;QAC3B,IAAI,OAAO,GAAkB,IAAI,CAAC;QAClC,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI;YACxB,OAAO,OAAO,CAAC;QACjB,IAAI,WAAW,GAAa,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;QAC1F,IAAI,WAAW,KAAK,IAAI;YACtB,OAAO,OAAO,CAAC;QAEjB,IAAI,KAAK,GAAW,MAAM,WAAW,CAAC,QAAQ,EAAE,CAAC;QACjD,IAAI,KAAK,KAAK,IAAI,EAAE;YAClB,OAAO,GAAG,IAAI,aAAa,EAAE,CAAC;YAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAY,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;YAC7D,IAAI,IAAI,CAAC,eAAe,KAAK,IAAI;gBAC/B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;SAClD;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAOD,YAAY,CAAC,UAAkB;QAC7B,IAAI,YAAY,GAAY,KAAK,CAAC;QAClC,IAAI,gBAAgB,GAAmB,KAAK,CAAC,OAAO,EAAE,CAAC;QAEvD,KAAK,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC;QAElC,OAAO,CAAC,YAAY,IAAI,gBAAgB,KAAK,IAAI,EAAE;YACjD,IAAI,UAAU,KAAK,gBAAgB;gBACjC,YAAY,GAAG,IAAI,CAAC;iBAEjB;gBACH,IAAI,QAAQ,GAAuB,gBAAgB,CAAC,OAAO,EAAE,CAAC;gBAC9D,IAAI,QAAQ,CAAC,SAAS,EAAE,KAAK,IAAI;oBAC/B,gBAAgB,GAAW,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC;;oBAE1D,MAAM;aACT;SACF;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAKM,KAAK,CAAC,mBAAmB;QAC9B,IAAI,CAAS,CAAC;QACd,IAAI,IAAI,GAAW,CAAC,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QAC1E,IAAI,IAAc,CAAC;QACnB,IAAI,OAAO,GAAY,KAAK,CAAC;QAE7B,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE;YACrC,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAEhC,QAAQ,IAAI,CAAC,KAAK,EAAE,EAAE;gBACpB,KAAK,aAAa,CAAC,cAAc;oBAC/B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE;wBACtG,OAAO,GAAG,IAAI,CAAC;wBACf,MAAM;qBACP;gBAEH,KAAK,aAAa,CAAC,gBAAgB,CAAC;gBACpC,KAAK,aAAa,CAAC,iBAAiB,CAAC;gBACrC,KAAK,aAAa,CAAC,iBAAiB,CAAC;gBACrC,KAAK,aAAa,CAAC,eAAe,CAAC;gBACnC,KAAK,aAAa,CAAC,oBAAoB;oBACrC,IAAI,IAAI,CAAC,YAAY,EAAE;wBACrB,OAAO,GAAG,IAAI,CAAC;oBACjB,MAAM;gBACR;oBACE,MAAM;aACT;YACD,IAAI,OAAO;gBACT,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;SAC/B;IACH,CAAC;IAED,KAAK,CAAC,MAAM;QACV,IAAI,OAAO,GAAY,KAAK,CAAC;QAG7B,IAAI,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YAC/B,MAAM,YAAY,CAAC,aAAa,CAAC,oCAAoC,CAAC,IAAI,EAAE,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;YAClH,OAAO,GAAG,IAAI,CAAC;SAChB;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,sBAA+B;QAC9C,IAAI,MAAM,GAAY,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;QAC9C,IAAI,MAAM,EAAE;YACV,MAAM,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;YAE7D,MAAM,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;YAC7D,MAAM,GAAG,MAAM,KAAK,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAC;SACzD;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAKD,gBAAgB;QACd,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAKD,eAAe;QACb,IAAI,KAAK,CAAC,SAAS,EAAE;YACnB,IAAI,CAAC,YAAY,GAAa,iBAAiB,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACjG,CAAC;IAKD,cAAc;QACZ,OAAkB,IAAI,CAAC,YAAY,CAAC;IACtC,CAAC;IAKD,KAAK,CAAC,eAAe;QACnB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI;YACtB,MAAc,IAAI,CAAC,MAAO,CAAC,aAAa,EAAE,CAAC;aACxC;YACH,KAAK,CAAC,YAAY,EAAE,CAAC;YACrB,MAAM,KAAK,CAAC,yBAAyB,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;SACvF;IACH,CAAC;IAKD,YAAY,CAAC,OAAiB;QAC5B,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;IAC5B,CAAC;IAKD,YAAY;QACV,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAKD,gBAAgB,CAAC,MAAc;QAC7B,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC;IAC/B,CAAC;IAMD,sBAAsB;QACpB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAMD,uBAAuB,CAAC,oBAA6B;QACnD,IAAI,CAAC,qBAAqB,GAAG,oBAAoB,CAAC;IACpD,CAAC;IAKD,uBAAuB,CAAC,IAAe;QACrC,IAAI,QAAQ,GAAY,KAAK,CAAC;QAC9B,IAAI,IAAI,KAAK,IAAI,EAAE;YACjB,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,EAAE;gBAC7D,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE;oBACxD,QAAQ,GAAG,IAAI,CAAC;aACnB;SACF;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAOD,UAAU,CAAC,IAAe;QACxB,IAAI,SAAS,GAAY,KAAK,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,CAAC;QACnF,IAAI,YAAY,GAAY,CAAC,SAAS,CAAE,IAAI,CAAC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;QAEhF,OAAO,YAAY,CAAC;IACtB,CAAC;IAMD,iBAAiB;QACf,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAMD,kBAAkB,CAAC,eAAwB;QACzC,IAAI,CAAC,gBAAgB,GAAG,eAAe,CAAC;IAC1C,CAAC;IAKD,gBAAgB;QACd,IAAI,gBAAgB,GAAY,KAAK,CAAC;QACtC,IAAI,cAAc,GAAa,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,wBAAwB,CAAC,CAAC;QACjG,IAAI,cAAc,KAAK,IAAI,IAAI,cAAc,CAAC,gBAAgB,EAAE,KAAK,IAAI;YACvE,gBAAgB,GAAG,IAAI,CAAC;QAE1B,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAMD,cAAc;QACZ,OAAO,IAAI,CAAC,cAAc,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,IAAI,IAAI,CAAS,KAAK,CAAC,QAAQ,EAAG,CAAC,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5I,CAAC;IASD,KAAK,CAAC,0BAA0B,CAAC,MAAc,EAAE,WAAwB,EAAE,GAAY,EAAE,UAAmB;QAC1G,IAAI,GAAG,IAAI,KAAK,CAAC,sBAAsB,EAAE;YACvC,GAAG,GAAG,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAGxC,IAAI,GAAG,IAAI,KAAK,CAAC,SAAS,EAAE,IAAI,WAAW,KAAK,WAAW,CAAC,gBAAgB,IAAI,IAAI,CAAC,yBAAyB,EAAE;YAC9G,GAAG,GAAG,KAAK,CAAC;QAEd,IAAI,UAAU,EAAE;YACd,QAAQ,CAAC,oBAAoB,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,EAC3D,WAAW,KAAK,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;SAEpI;QACD,MAAM,KAAK,CAAC,uBAAuB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,CAAC,CAAC;IAChE,CAAC;IAMO,yBAAyB;QAC/B,IAAI,YAAY,GAAY,KAAK,CAAC;QAClC,IAAI,WAAW,GAA6B,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC,uBAAuB,EAAE,CAAC;QACtI,IAAI,WAAW,KAAK,WAAW,CAAC,IAAI,IAAI,IAAI,CAAC,gBAAgB,EAAE,KAAK,IAAI;YACtE,YAAY,GAAG,IAAI,CAAC;QACtB,OAAO,YAAY,CAAC;IACtB,CAAC;IAQD,KAAK,CAAC,8BAA8B,CAAC,MAAc,EAAE,WAAwB,EAAE,GAAY;QACzF,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;QAEhC,IAAI,CAAY,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,EAAG,CAAC,sBAAsB;YAC/D,OAAO;QAET,IAAI,WAAW,GAA6B,KAAK,CAAC,mBAAmB,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC,uBAAuB,EAAE,CAAC;QACtI,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,IAAI,WAAW,KAAK,WAAW,CAAC,IAAI,EAAE;YACpE,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,EAAE;gBAC/D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;gBAC1B,IAAI,WAAW,KAAK,WAAW,CAAC,gBAAgB,IAAI,GAAG,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBAChF,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;oBAC9B,MAAiB,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,EAAG,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;iBACrF;gBAED,IAAI,WAAW,GAAe,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;gBAC1D,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,YAAY,EAAE,EAAE,CAAC,EAAE,EAAE;oBAC3D,IAAI,KAAK,GAAkB,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;oBAGlD,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE;wBAC1B,SAAS;oBACX,IAAI,UAAU,GAAY,MAAM,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC;oBACrE,IAAI,UAAU;wBACZ,UAAU,GAAG,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;oBAI/C,MAAM,KAAK,CAAC,uBAAuB,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;iBACtE;aACF;SACF;aACI,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,gBAAgB,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACrF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,MAAM,YAAY,CAAC,aAAa,CAAC,oCAAoC,CAAC,IAAI,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;SACpH;IACH,CAAC;IAKD,IAAI;QACF,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAMD,iBAAiB;QACf,OAAO,cAAc,CAAC,cAAc,CAAC;IACvC,CAAC;IAQD,KAAK,CAAC,mBAAmB,CAAC,QAAa,EAAE,UAAmB;QAC1D,KAAK,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QAIrC,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,IAAI,aAAa,GAAQ,IAAI,CAAC,KAAK,CAAC;YACpC,IAAI,EAAqB,CAAC;YAE1B,IAAI,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI;gBACzB,OAAO,IAAI,CAAC;YACd,EAAE,GAAG,KAAK,CAAC,YAAY,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;YAEjD,EAAE,CAAC,QAAQ,EAAE,CAAC;YAGd,IAAI,EAAE,CAAC,gBAAgB,EAAE;gBACvB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;gBAC5B,OAAO,KAAK,CAAC;aACd;YAED,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAEhC,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YAG/C,IAAI,UAAU,EAAE;gBAMd,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,gBAAgB,CAAC,OAAO,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;oBAC1I,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBAExB,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;aACzB;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAOO,KAAK,CAAC,QAAQ,CAAC,EAAqB;QAC1C,IAAI,MAAM,GAAY,EAAE,CAAC,SAAS,EAAE,CAAC;QACrC,IAAI,QAAQ,GAAQ,EAAE,CAAC,YAAY,EAAE,CAAC;QACtC,IAAI,KAAa,CAAC;QAElB,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE;YAC/C,KAAK,GAAG,MAAM,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;;YAGzC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC;QACzI,IAAI,KAAK,KAAK,IAAI,EAAE;YAClB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,EAAE;gBACtG,MAAc,IAAI,CAAC,MAAO,CAAC,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;gBAOvF,IAAI,KAAK,CAAC,UAAU,EAAE,EAAE;oBACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;oBACzB,KAAK,GAAW,IAAI,CAAC,MAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;iBAC9C;aACF;YAGD,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE;gBACvE,KAAK,GAAG,QAAQ,CAAC;YAEnB,MAAM,KAAK,CAAC,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACrD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAE1B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;SAC1B;IACH,CAAC;IAKD,cAAc;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAKD,gBAAgB;QACd,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC;IAC5B,CAAC;IAID,gBAAgB;QACd,IAAI,IAAI,GAAe,IAAI,CAAC;QAC5B,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI;YAC5B,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAKD,4BAA4B;QAC1B,IAAI,0BAA0B,GAAY,KAAK,CAAC;QAChD,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC,eAAe,EAAE,mEAAmE,CAAC,CAAC;QAC/H,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC,0BAA0B,CAAC;YACpE,0BAA0B,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,CAAC,0BAA0B,CAAC,CAAC,uBAAuB,EAAE,KAAa,kBAAkB,CAAC,QAAQ,CAAC,CAAC;QAEvK,OAAO,0BAA0B,CAAC;IACpC,CAAC;IAID,MAAM,CAAC,iBAAiB;QACtB,IAAI,SAAS,CAAC,YAAY,KAAK,IAAI,IAAI,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE;YAC5F,OAAO,KAAK,CAAC;QAEf,OAAO,IAAI,CAAC;IACd,CAAC;IAGD,WAAW;QACT,QAAQ,IAAI,CAAC,IAAI,EAAE;YACjB,KAAK,aAAa,CAAC,kBAAkB,CAAC;YACtC,KAAK,aAAa,CAAC,cAAc,CAAC;YAClC,KAAK,aAAa,CAAC,eAAe,CAAC;YACnC,KAAK,aAAa,CAAC,cAAc,CAAC;YAClC,KAAK,aAAa,CAAC,eAAe,CAAC;YACnC,KAAK,aAAa,CAAC,aAAa;gBAC9B,MAAM;YAER;gBACE,OAAO,KAAK,CAAC;SAChB;QAGD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,SAAS,GAAG,CAAC;YAC5C,OAAO,KAAK,CAAC;QAEf,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC;IAC7B,CAAC;IAQD,KAAK,CAAC,4BAA4B,CAAC,QAAa,EAAE,cAAuB;QACvE,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE;YACvB,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,kEAAkE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAC/H,OAAO,KAAK,CAAC;SACd;QAED,IAAI,MAAM,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM;YACT,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,kCAAkC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAEjG,IAAI,cAAc,EAAE;YAClB,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;YACnE,QAAQ,CAAC,MAAM,EAAE,CAAC;SACnB;QAGD,OAAO,MAAM,CAAC;IAChB,CAAC;;AApkBM,sBAAY,GAAc,IAAI,CAAC","sourcesContent":["import {\r\n  Commands,\r\n  CommandType,\r\n  GuiDataCollection,\r\n  HtmlProperties,\r\n  MgControlBase,\r\n  MgFormBase,\r\n  Property,\r\n  PropInterface,\r\n  PropParentInterface,\r\n  ValidationDetails\r\n} from '@magic-xpa/gui';\r\nimport {\r\n  InternalInterface,\r\n  Logger,\r\n  MgControlType,\r\n  ScrollBarThumbType,\r\n  StorageAttribute,\r\n  SubformType,\r\n  TableBehaviour,\r\n  XmlParser\r\n} from '@magic-xpa/utils';\r\nimport {Debug, NString} from '@magic-xpa/mscorelib';\r\nimport {ArgumentsList} from '../rt/ArgumentsList';\r\nimport {TaskBase} from '../tasks/TaskBase';\r\nimport {MgForm} from './MgForm';\r\nimport {Field} from '../data/Field';\r\nimport {DataView} from '../data/DataView';\r\nimport {ConstInterface} from '../ConstInterface';\r\nimport {AccessHelper} from '../AccessHelper';\r\n\r\n/// <summary>\r\n///   data for <control> ...</control> tag\r\n/// </summary>\r\n/// <author>  ehudm\r\n///\r\n/// </author>\r\nexport class MgControl extends MgControlBase implements PropParentInterface {\r\n  private _focusedStopExecution: boolean; // used to remember stopExecution flag in the end of\r\n  private _inControlSuffix: boolean; // true, is control is in control suffix\r\n  private _rtEvtTask: TaskBase;\r\n\r\n  private _subformTaskId: string; // the task id of the sub form task (if this\r\n  private _subformTask: TaskBase; // reference to task of the sub form task\r\n\r\n  IsInteractiveUpdate: boolean; // true if this control was modified by user\r\n  private refreshOnString: string; // Only for offline. Get it from XML and put it on the subform task when the subform task is opened\r\n  SubformLoaded: boolean; // true, if the subform task was loaded already\r\n  HasZoomHandler: boolean; // if TRUE, there is a zoom handler on this ctrl\r\n  ArgList: ArgumentsList; // argument list built from the property\r\n\r\n  static ReturnToCtrl: MgControl = null;\r\n\r\n  private initialize() {\r\n    this._focusedStopExecution = false;\r\n    this._inControlSuffix = false;\r\n    this._rtEvtTask = null;\r\n    this._subformTaskId = null;\r\n    this._subformTask = null;\r\n    this.IsInteractiveUpdate = false;\r\n    this.refreshOnString = null;\r\n    this.SubformLoaded = false;\r\n    this.HasZoomHandler = false;\r\n    this.ArgList = null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  constructor();\r\n  constructor(type: MgControlType);\r\n  constructor(type: MgControlType, task: TaskBase, parentControl: number);\r\n  constructor(type: MgControlType, parentMgForm: MgFormBase, parentControlIdx: number);\r\n  constructor(type?: MgControlType, taskOrParentMgForm?: any, parentControlOrParentControlIdx?: number) {\r\n    if (arguments.length === 0)\r\n      super();\r\n    else if (arguments.length === 3 && (type === null || type.constructor === Number) && (taskOrParentMgForm === null || taskOrParentMgForm instanceof TaskBase) && (parentControlOrParentControlIdx === null || parentControlOrParentControlIdx.constructor === Number))\r\n      super(type, taskOrParentMgForm.getForm(), parentControlOrParentControlIdx);\r\n    else\r\n      super(type, taskOrParentMgForm, parentControlOrParentControlIdx);\r\n\r\n    this.initialize();\r\n  }\r\n\r\n  GetVarIndex(): number {\r\n    return (<DataView>super.getForm().getTask().DataView).Dvcount + this.veeIndx;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Set arguments from the property\r\n  /// </summary>\r\n  /// <param name=\"mgForm\"></param>\r\n  /// <param name=\"ditIdx\"></param>\r\n  async fillData(mgForm: MgFormBase, ditIdx: number, parser: XmlParser): Promise<void> {\r\n    super.fillData(mgForm, ditIdx, parser);\r\n    this.ArgList = await this.GetArgumentList();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the control attributes\r\n  /// </summary>\r\n  SetAttribute(attribute: string, valueStr: string): boolean {\r\n    let isTagProcessed: boolean = super.SetAttribute(attribute, valueStr);\r\n    if (!isTagProcessed) {\r\n      switch (attribute) {\r\n        case ConstInterface.MG_ATTR_SUBFORM_TASK:\r\n          if (valueStr.trim() != \"\")\r\n            this._subformTaskId = valueStr;\r\n          break;\r\n        case ConstInterface.MG_ATTR_REFRESHON:\r\n          this.refreshOnString = valueStr.trim();\r\n          break;\r\n        default:\r\n          isTagProcessed = false;\r\n          Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unrecognized attribute: '{0}'\", attribute));\r\n          break;\r\n      }\r\n    }\r\n    return isTagProcessed;\r\n  }\r\n\r\n  /// <summary>\r\n  /// build Argument list from the property\r\n  /// </summary>\r\n  private async GetArgumentList(): Promise<ArgumentsList> {\r\n    let argList: ArgumentsList = null;\r\n    if (this._propTab === null)\r\n      return argList;\r\n    let ArgListProp: Property = this._propTab.getPropById(PropInterface.PROP_TYPE_PARAMETERS);\r\n    if (ArgListProp === null)\r\n      return argList;\r\n\r\n    let parms: string = await ArgListProp.getValue();\r\n    if (parms !== null) {\r\n      argList = new ArgumentsList();\r\n      argList.fillList(parms, <TaskBase>super.getForm().getTask());\r\n      if (this.refreshOnString !== null)\r\n        argList.RefreshOnString = this.refreshOnString;\r\n    }\r\n    return argList;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return true if this control is descendant of the parentForm\r\n  /// </summary>\r\n  /// <param name = \"parentForm\"></param>\r\n  /// <returns></returns>\r\n  isDescendent(parentForm: MgForm): boolean {\r\n    let isDescendent: boolean = false;\r\n    let checkCurrentForm: MgForm = <MgForm>super.getForm();\r\n\r\n    Debug.Assert(parentForm !== null);\r\n\r\n    while (!isDescendent && checkCurrentForm !== null) {\r\n      if (parentForm === checkCurrentForm)\r\n        isDescendent = true;\r\n\r\n      else {\r\n        let currTask: TaskBase = <TaskBase>checkCurrentForm.getTask();\r\n        if (currTask.getParent() !== null)\r\n          checkCurrentForm = <MgForm>currTask.getParent().getForm();\r\n        else\r\n          break;\r\n      }\r\n    }\r\n    return isDescendent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Refresh control display if it has a property which is an expression\r\n  /// </summary>\r\n  public async refreshOnExpression(): Promise<void> {\r\n    let i: number;\r\n    let size: number = (this._propTab === null ? 0 : this._propTab.getSize());\r\n    let prop: Property;\r\n    let refresh: boolean = false;\r\n\r\n    for (i = 0; i < size && !refresh; i++) {\r\n      prop = this._propTab.getProp(i);\r\n\r\n      switch (prop.getID()) {\r\n        case PropInterface.PROP_TYPE_DATA:\r\n          if (!prop.isExpression() && this._field !== null && this._field.getTask() !== this.getForm().getTask()) {\r\n            refresh = true;\r\n            break;\r\n          }\r\n        /*  falls through */\r\n        case PropInterface.PROP_TYPE_FORMAT:\r\n        case PropInterface.PROP_TYPE_VISIBLE:\r\n        case PropInterface.PROP_TYPE_ENABLED:\r\n        case PropInterface.PROP_TYPE_RANGE:\r\n        case PropInterface.PROP_TYPE_TRANSLATOR:\r\n          if (prop.isExpression())\r\n            refresh = true;\r\n          break;\r\n        default:\r\n          break;\r\n      }\r\n      if (refresh)\r\n        await this.RefreshDisplay();\r\n    }\r\n  }\r\n\r\n  async invoke(): Promise<boolean> {\r\n    let invoked: boolean = false;\r\n\r\n    // if the control is not visible, not enabled or not parkable skip this control\r\n    if (await this.isParkable(true)) {\r\n      await AccessHelper.eventsManager.handleInternalEventWithMgControlBase(this, InternalInterface.MG_ACT_CTRL_PREFIX);\r\n      invoked = true;\r\n    }\r\n    return invoked;\r\n  }\r\n\r\n  async isParkable(checkEnabledAndVisible: boolean): Promise<boolean> {\r\n    let result: boolean = !super.isImageControl();\r\n    if (result) {\r\n      await super.checkProp(PropInterface.PROP_TYPE_ENABLED, true);\r\n\r\n      await super.checkProp(PropInterface.PROP_TYPE_VISIBLE, true);\r\n      result = await super.isParkable(checkEnabledAndVisible);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the subform task id of the control\r\n  /// </summary>\r\n  getSubformTaskId(): string {\r\n    return this._subformTaskId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   find the subform task according to its id and save it\r\n  /// </summary>\r\n  initSubformTask(): void {\r\n    if (super.isSubform())\r\n      this._subformTask = <TaskBase>GuiDataCollection.MGDataTable.GetTaskByID(this._subformTaskId);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the control's parentTable\r\n  /// </summary>\r\n  getParentTable(): MgControl {\r\n    return <MgControl>this._parentTable;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   restore and display the old value of the control used when the control is not modifiable\r\n  /// </summary>\r\n  async restoreOldValue(): Promise<void> {\r\n    if (this._field !== null)\r\n      await (<Field>this._field).updateDisplay();\r\n    else {\r\n      super.resetPrevVal();\r\n      await super.SetAndRefreshDisplayValue(await this.getMgValue(this.Value), this.IsNull);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the event task\r\n  /// </summary>\r\n  setRtEvtTask(curTask: TaskBase): void {\r\n    this._rtEvtTask = curTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the event task\r\n  /// </summary>\r\n  getRtEvtTask(): TaskBase {\r\n    return this._rtEvtTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the subform task id of the control\r\n  /// </summary>\r\n  setSubformTaskId(taskId: string): void {\r\n    this._subformTaskId = taskId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns stopExecution flag in the end of handle focus on the control\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isFocusedStopExecution(): boolean {\r\n    return this._focusedStopExecution;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   remember stopExecution flag in the end of handle focus on the control\r\n  /// </summary>\r\n  /// <param name = \"focusedStopExecution\"></param>\r\n  setFocusedStopExecution(focusedStopExecution: boolean): void {\r\n    this._focusedStopExecution = focusedStopExecution;\r\n  }\r\n\r\n  /// <param name = \"ctrl-\">The ctrl to check. can be frame form and also subform control\r\n  /// </param>\r\n  /// <returns></returns>\r\n  onTheSameSubFormControl(ctrl: MgControl): boolean {\r\n    let retValue: boolean = false;\r\n    if (ctrl !== null) {\r\n      if (super.getForm().isSubForm() && ctrl.getForm().isSubForm()) {\r\n        if (super.getForm().getTask() === ctrl.getForm().getTask())\r\n          retValue = true;\r\n      }\r\n    }\r\n    return retValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   true if the ctrls are on different forms\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <returns></returns>\r\n  onDiffForm(ctrl: MgControl): boolean {\r\n    let isSubform: boolean = super.getForm().isSubForm() || ctrl.getForm().isSubForm();\r\n    let isOnDiffForm: boolean = (isSubform ) && !this.onTheSameSubFormControl(ctrl);\r\n\r\n    return isOnDiffForm;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   true if control is in control suffix\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isInControlSuffix(): boolean {\r\n    return this._inControlSuffix;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set true if control is in control suffix\r\n  /// </summary>\r\n  /// <param name = \"inControlSuffix\"></param>\r\n  setInControlSuffix(inControlSuffix: boolean): void {\r\n    this._inControlSuffix = inControlSuffix;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return true if the control has select program\r\n  /// </summary>\r\n  HasSelectProgram(): boolean {\r\n    let HasSelectProgram: boolean = false;\r\n    let selectProgProp: Property = super.GetComputedProperty(PropInterface.PROP_TYPE_SELECT_PROGRAM);\r\n    if (selectProgProp !== null && selectProgProp.GetComputedValue() !== null)\r\n      HasSelectProgram = true;\r\n\r\n    return HasSelectProgram;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return true if the control use the handler ZOOM (for select program or Zoom handler)\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  useZoomHandler(): boolean {\r\n    return this.HasZoomHandler || (super.getField() !== null && ((<Field>super.getField()).getHasZoomHandler() || (this.HasSelectProgram())));\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 && super.haveToCheckParentValue())\r\n      val = super.isParentPropValue(propId);\r\n\r\n    // if the subform must be invisible (CTRL_SUBFORM_NONE) we change its visibility to false\r\n    if (val && super.isSubform() && commandType === CommandType.PROP_SET_VISIBLE && this.ShouldSetSubformInvisible())\r\n      val = false;\r\n\r\n    if (updateThis) {\r\n      Commands.addOperationWithLine(CommandType.SET_PROPERTY, this, super.getDisplayLine(false),\r\n                                    commandType === CommandType.PROP_SET_VISIBLE ? HtmlProperties.Visible : HtmlProperties.Enabled, val);\r\n\r\n    }\r\n    await super.updateChildrenPropValue(propId, commandType, val);\r\n  }\r\n\r\n  /// <summary>\r\n  /// If the subform must be invisible (for example CTRL_SUBFORM_NONE) returns true.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private ShouldSetSubformInvisible(): boolean {\r\n    let setInvisible: boolean = false;\r\n    let subformType: SubformType = <SubformType>super.GetComputedProperty(PropInterface.PROP_TYPE_SUBFORM_TYPE).GetComputedValueInteger();\r\n    if (subformType === SubformType.None && this.getSubformTaskId() === null)\r\n      setInvisible = true;\r\n    return setInvisible;\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  async updateSubformChildrenPropValue(propId: number, commandType: CommandType, val: boolean): Promise<void> {\r\n    Debug.Assert(super.isSubform());\r\n\r\n    if (!(<TaskBase>super.getForm().getTask()).AfterFirstRecordPrefix)\r\n      return;\r\n\r\n    let subformType: SubformType = <SubformType>super.GetComputedProperty(PropInterface.PROP_TYPE_SUBFORM_TYPE).GetComputedValueInteger();\r\n    if (this._subformTaskId !== null || subformType === SubformType.None) {\r\n      if (this._subformTask !== null && this._subformTask.isStarted()) {\r\n        this.SubformLoaded = true;\r\n        if (commandType === CommandType.PROP_SET_VISIBLE && val && this.RefreshOnVisible) {\r\n          this.RefreshOnVisible = false;\r\n          await (<TaskBase>super.getForm().getTask()).SubformRefresh(this._subformTask, true);\r\n        }\r\n\r\n        let subformForm: MgFormBase = this._subformTask.getForm();\r\n        for (let i: number = 0; i < subformForm.getCtrlCount(); i++) {\r\n          let child: MgControlBase = subformForm.getCtrl(i);\r\n          // QCR #981555, We should not affect visibility of the TableColumns since it is managed by the table.Setting visibility\r\n          // of all columns to false prevents table placement\r\n          if (!child.isColumnControl())\r\n            continue;\r\n          let childValue: boolean = await child.checkProp(propId, true) && val;\r\n          if (childValue)\r\n            childValue = child.isParentPropValue(propId);\r\n\r\n          // if (this._subformTask.isStarted())\r\n          //   Commands.addAsync(commandType, child, child.getDisplayLine(false), childValue);\r\n          await child.updateChildrenPropValue(propId, commandType, childValue);\r\n        }\r\n      }\r\n    }\r\n    else if ((commandType === CommandType.PROP_SET_VISIBLE && val) && !this.SubformLoaded) {\r\n      this.SubformLoaded = true;\r\n      await AccessHelper.eventsManager.handleInternalEventWithMgControlBase(this, InternalInterface.MG_ACT_SUBFORM_OPEN);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Set subform task id for a subform control\r\n  /// </summary>\r\n  Init(): void {\r\n    this.initSubformTask();\r\n  }\r\n\r\n  /// <summary>\r\n  /// get the behaviour for the table control\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetTableBehaviour(): TableBehaviour {\r\n    return TableBehaviour.UnlimitedItems;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   validate the value of the control and set it's value\r\n  /// </summary>\r\n  /// <param name = \"NewValue\">the value of the control</param>\r\n  /// <param name = \"updateCtrl\">if true then the control will be updated upon successful check</param>\r\n  /// <returns>returns if validation is successful</returns>\r\n  async validateAndSetValue(NewValue: any, updateCtrl: boolean): Promise<boolean> {\r\n    super.UpdateModifiedByUser(NewValue);\r\n\r\n    // if the value of the control is null or was changed\r\n    // check validation and update the control value\r\n    if (this.ModifiedByUser) {\r\n      let ctrlCurrValue: any = this.Value;\r\n      let vd: ValidationDetails;\r\n\r\n      if (super.getPIC() === null)\r\n        return true;\r\n      vd = super.buildPicture(ctrlCurrValue, NewValue);\r\n\r\n      vd.evaluate();\r\n\r\n      // the validation of the fields value was wrong\r\n      if (vd.ValidationFailed) {\r\n        this.ModifiedByUser = false;\r\n        return false;\r\n      }\r\n\r\n      this.IsInteractiveUpdate = true;\r\n\r\n      super.getForm().getTask().setDataSynced(false);\r\n\r\n      // set the value (handle recompute, etc.)\r\n      if (updateCtrl) {\r\n        // QCR#441020:After validating display value, take the same ctrl's value for mg value conversion.\r\n        // Using display value generated from MgValue, might have problem to convert back to MgVal using picture due to alignment (changed alignment ).\r\n        // This problem occurs for numeric.\r\n        // The fix should be applicable for numeric type only. Because date and time field with complex masking have problem on using ctrl's value.\r\n        // Refer date qcrs: #291666, #307353, #434241 and for time, check default value when format is 'HH-MM-SS PMZ@'\r\n        if (this._field !== null && this._field.getType() === StorageAttribute.NUMERIC && typeof NewValue === 'string' && NewValue.trim().length > 0)\r\n          vd.setValue(NewValue);\r\n\r\n        await this.setValue(vd);\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value received from the user input after validation and update the field connected to this\r\n  ///   control (if exists)\r\n  /// </summary>\r\n  /// <param name = \"vd\">the validation details object</param>\r\n  private async setValue(vd: ValidationDetails): Promise<void> {\r\n    let isNull: boolean = vd.getIsNull();\r\n    let newValue: any = vd.getDispValue();\r\n    let mgVal: string;\r\n\r\n    if (!isNull || !this._field.hasNullDisplayValue())\r\n      mgVal = await super.getMgValue(newValue);\r\n    // it's inner value -> translate it to the display\r\n    else\r\n      mgVal = ((this._field.getType() === StorageAttribute.BLOB_VECTOR) ? this._field.getCellDefualtValue() : this._field.getDefaultValue());\r\n    if (mgVal !== null) {\r\n      if (this._field !== null && (!(newValue === this.Value) || this.KeyStrokeOn || this.IsNull !== isNull)) {\r\n        await (<Field>this._field).setValueAndStartRecompute(mgVal, isNull, true, true, false);\r\n\r\n        // defect 127734 : value of the field might be changed already inside a control change handler\r\n        // to avoid updating old value and overrunning the value fr0m the control change\r\n        // get the value from the field. (need to be done for combo and list box, but it's too risky\r\n        // and unlikely to happen, so the fix will be for check box only)\r\n\r\n        if (super.isCheckBox()) {\r\n          this.forceRefresh = true;\r\n          mgVal = (<Field>this._field).getValue(false);\r\n        }\r\n      }\r\n\r\n      // if field value is null & has null display value, take evaluated null display value.\r\n      if ((this._field !== null && isNull) && this._field.hasNullDisplayValue())\r\n        mgVal = newValue;\r\n\r\n      await super.SetAndRefreshDisplayValue(mgVal, isNull);\r\n      this.forceRefresh = false;\r\n      // QCR #438753. Prevent RP&RS cycle, when it's not needed.\r\n      this.KeyStrokeOn = false;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the subform task of this subform control\r\n  /// </summary>\r\n  getSubformTask(): TaskBase {\r\n    return this._subformTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the subform task of this subform control\r\n  /// </summary>\r\n  resetSubformTask(): void {\r\n    this._subformTask = null;\r\n    this._subformTaskId = \"0\";\r\n  }\r\n  /// <summary>\r\n  /// returns MgForm of the subform control task\r\n  /// </summary>\r\n  GetSubformMgForm(): MgFormBase {\r\n    let form: MgFormBase = null;\r\n    if (this._subformTask !== null)\r\n      form = this._subformTask.getForm();\r\n    return form;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Check whether table being used with absolute scrollbar thumb.\r\n  /// </summary>\r\n  IsTableWithAbsoluteScrollbar(): boolean {\r\n    let tableWithAbsoluteScrollbar: boolean = false;\r\n    Debug.Assert(this.Type === MgControlType.CTRL_TYPE_TABLE, \"In MgControl.IsTableWithAbsoluteScrollbar(): Not a table control.\");\r\n    if (this._propTab.propExists(PropInterface.PROP_TYPE_SCROLL_BAR_THUMB))\r\n      tableWithAbsoluteScrollbar = (this._propTab.getPropById(PropInterface.PROP_TYPE_SCROLL_BAR_THUMB).GetComputedValueInteger() === <number>ScrollBarThumbType.Absolute);\r\n\r\n    return tableWithAbsoluteScrollbar;\r\n  }\r\n\r\n\r\n  /// <summary> check if the return-to-control points to an existing task.</summary>\r\n  static validReturnToCtrl(): boolean {\r\n    if (MgControl.ReturnToCtrl !== null && MgControl.ReturnToCtrl.getForm().getTask().isAborting())\r\n      return false;\r\n\r\n    return true;\r\n  }\r\n\r\n  /// <summary> check if one may directly (not via the gui) set a value on this control.</summary>\r\n  maySetValue(): boolean {\r\n    switch (this.Type) {\r\n      case MgControlType.CTRL_TYPE_CHECKBOX:\r\n      case MgControlType.CTRL_TYPE_TEXT:\r\n      case MgControlType.CTRL_TYPE_COMBO:\r\n      case MgControlType.CTRL_TYPE_LIST:\r\n      case MgControlType.CTRL_TYPE_RADIO:\r\n      case MgControlType.CTRL_TYPE_TAB:\r\n        break;\r\n\r\n      default:\r\n        return false;\r\n    }\r\n\r\n    // prevent value setting if the control doesn't have a field, or if it gets its value from an expression\r\n    if (this._field === null || this._valExpId > 0)\r\n      return false;\r\n\r\n    return this.isModifiable();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Checks if a value may be set, and tries to set the value of the control\r\n  /// </summary>\r\n  /// <param name = \"NewValue\">the value of the control</param>\r\n  /// <param name = \"updateCtrl\">if true then the control will be updated upon successful check</param>\r\n  /// <returns>returns if value setting was successful </returns>\r\n  async validateAndSetValueIfAllowed(NewValue: any, refreshDisplay: boolean): Promise<boolean> {\r\n    if (!this.maySetValue()) {\r\n      Logger.Instance.WriteErrorToLog(NString.Format(\"Unable to change value of control {0}: The control is read-only.\", this.Name));\r\n      return false;\r\n    }\r\n\r\n    let retVal = await this.validateAndSetValue(NewValue, true);\r\n    if (!retVal)\r\n      Logger.Instance.WriteErrorToLog(NString.Format(\"Value validation failed for {0}.\", this.Name));\r\n\r\n    if (refreshDisplay) {\r\n      Commands.addNoParameters(CommandType.REFRESH_TASK, this.getForm());\r\n      Commands.invoke();\r\n    }\r\n\r\n    //refresh task\r\n    return retVal;\r\n  }\r\n}\r\n"]}