@magic-xpa/gui 4.1100.0-dev4110.99 → 4.1100.0

package/esm2022/src/management/exp/GuiExpressionEvaluator.mjs

@@ -0,0 +1,305 @@
+import { ApplicationException, NString } from '@magic-xpa/mscorelib';
+import { Rtf, StorageAttribute, StorageAttributeCheck, StrUtil } from '@magic-xpa/utils';
+import { Manager } from '../../Manager';
+import { NUM_TYPE } from '../data/NUM_TYPE';
+import { BlobType } from '../data/BlobType';
+import { DisplayConvertor } from '../gui/DisplayConvertor';
+export class GuiExpressionEvaluator {
+    static TRIGGER_TASK = 500000;
+    ExpTask = null;
+    Events = null;
+    eval_op_statusbar_set_text(resVal, statusBarText) {
+        resVal.Attr = StorageAttribute.UNICODE;
+        resVal.StrVal = Manager.GetCurrentRuntimeContext().DefaultStatusMsg;
+        if (Manager.GetCurrentRuntimeContext().DefaultStatusMsg === null) {
+            resVal.StrVal = '';
+        }
+        else {
+            resVal.StrVal = Manager.GetCurrentRuntimeContext().DefaultStatusMsg;
+        }
+        resVal.IsNull = false;
+        if (!(statusBarText.Attr !== StorageAttribute.ALPHA && statusBarText.Attr !== StorageAttribute.UNICODE)) {
+            if (!statusBarText.IsNull) {
+                let text = statusBarText.StrVal;
+                let task = this.ExpTask.GetContextTask();
+                if (task.getForm() === null && Manager.GetCurrentRuntimeContext().FrameForm !== null) {
+                    task = Manager.GetCurrentRuntimeContext().FrameForm.getTask();
+                }
+                task.WriteToMessagePane(text);
+                Manager.GetCurrentRuntimeContext().DefaultStatusMsg = text;
+            }
+        }
+    }
+    IsParallel() {
+        return false;
+    }
+    eval_op_ctrl_name(resVal) {
+        let lastClickedCtrlName = Manager.GetCurrentRuntimeContext().LastClickedCtrlName;
+        resVal.StrVal = (NString.IsNullOrEmpty(lastClickedCtrlName) ? '' : lastClickedCtrlName);
+        resVal.Attr = StorageAttribute.ALPHA;
+    }
+    eval_op_gotoCtrl(ctrlName, rowNum, generation, retVal) {
+        retVal.Attr = StorageAttribute.BOOLEAN;
+        retVal.BoolVal = false;
+        let task = this.GetContextTask(generation.MgNumVal.NUM_2_LONG());
+        if (task === null || task.getForm() === null)
+            return;
+        let iRowNum = rowNum.MgNumVal.NUM_2_LONG();
+        let sCtrlName = StrUtil.rtrim(ctrlName.StrVal);
+        let ctrl = task.getForm().GetCtrl(sCtrlName);
+        retVal.BoolVal = this.HandleControlGoto(task, ctrl, iRowNum);
+    }
+    static GetContextTask(currTask, generation) {
+        let task = null;
+        let taskBase = currTask.GetContextTask();
+        if (generation === GuiExpressionEvaluator.TRIGGER_TASK) {
+            task = taskBase;
+        }
+        else {
+            if (generation < taskBase.GetTaskDepth()) {
+                task = taskBase.GetTaskAncestor(generation);
+            }
+        }
+        return task;
+    }
+    GetContextTask(generation) {
+        return GuiExpressionEvaluator.GetContextTask(this.ExpTask, generation);
+    }
+    ConstructMagicNum(resVal, i, attr) {
+        resVal.MgNumVal = new NUM_TYPE();
+        resVal.MgNumVal.NUM_4_LONG(i);
+        resVal.Attr = attr;
+    }
+    SetNULL(resVal, attr) {
+        resVal.IsNull = true;
+        resVal.Attr = attr;
+        switch (attr) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+                resVal.StrVal = null;
+                break;
+            case StorageAttribute.TIME:
+            case StorageAttribute.DATE:
+            case StorageAttribute.NUMERIC:
+                resVal.MgNumVal = null;
+                break;
+            case StorageAttribute.BOOLEAN:
+                resVal.BoolVal = false;
+                break;
+            default:
+                break;
+        }
+    }
+    GetValidatedValue(currCtrl, oldValue, newValue) {
+        let vd = currCtrl.buildCopyPicture(oldValue, newValue);
+        vd.evaluate();
+        let validationFailed = vd.ValidationFailed;
+        let ctrlValue;
+        if (validationFailed) {
+            let field = currCtrl.getField();
+            ctrlValue = ((field.getType() === StorageAttribute.BLOB_VECTOR) ? field.getCellDefualtValue() : field.getDefaultValue());
+        }
+        else {
+            ctrlValue = vd.getDispValue();
+        }
+        return ctrlValue;
+    }
+    SetVal(resVal, type, val, pic) {
+        switch (type) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.BLOB:
+            case StorageAttribute.BLOB_VECTOR:
+            case StorageAttribute.UNICODE:
+                resVal.Attr = type;
+                resVal.StrVal = val;
+                if (type === StorageAttribute.BLOB || type === StorageAttribute.BLOB_VECTOR)
+                    resVal.IncludeBlobPrefix = true;
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                resVal.Attr = type;
+                if (val == null)
+                    resVal.MgNumVal = null;
+                else if (pic == null)
+                    resVal.MgNumVal = new NUM_TYPE(val);
+                else
+                    resVal.MgNumVal = new NUM_TYPE(val, pic, (this.ExpTask).getCompIdx());
+                break;
+            case StorageAttribute.BOOLEAN:
+                resVal.Attr = type;
+                resVal.BoolVal = DisplayConvertor.toBoolean(val);
+                break;
+            default:
+                this.SetNULL(resVal, type);
+                this.Events.WriteExceptionToLog('ExpressionEvaluator.SetVal() there is no such type : ' + type);
+                break;
+        }
+    }
+    static exp_build_string(val) {
+        let name = '';
+        if (val.StrVal !== null) {
+            let len = val.StrVal.length;
+            if (len > 0) {
+                name = StrUtil.ZstringMake(val.StrVal, len);
+            }
+        }
+        return name;
+    }
+    static isExpVal(obj) {
+        return obj instanceof ExpVal;
+    }
+    BlobStringConversion(val, expectedType) {
+        if (StorageAttributeCheck.IsTypeAlphaOrUnicode(expectedType)) {
+            if (val.Attr === StorageAttribute.BLOB) {
+                let includeBlobPrefix = val.IncludeBlobPrefix;
+                if (includeBlobPrefix) {
+                    let contentType = BlobType.getContentType(val.StrVal);
+                    val.StrVal = BlobType.getString(val.StrVal);
+                    val.IncludeBlobPrefix = false;
+                    if (contentType !== BlobType.CONTENT_TYPE_BINARY && Rtf.isRtf(val.StrVal)) {
+                        val.StrVal = StrUtil.GetPlainTextfromRtf(val.StrVal);
+                    }
+                }
+                val.Attr = expectedType;
+            }
+            else {
+                if (val.Attr === StorageAttribute.BLOB_VECTOR) {
+                    let includeBlobPrefix2 = val.IncludeBlobPrefix;
+                    if (includeBlobPrefix2) {
+                        val.StrVal = BlobType.removeBlobPrefix(val.StrVal);
+                        val.IncludeBlobPrefix = false;
+                    }
+                    val.Attr = expectedType;
+                }
+            }
+        }
+        else {
+            if (expectedType === StorageAttribute.BLOB) {
+                if (StorageAttributeCheck.IsTypeAlphaOrUnicode(val.Attr)) {
+                    let contentType = (val.Attr === StorageAttribute.ALPHA) ? BlobType.CONTENT_TYPE_ANSI : BlobType.CONTENT_TYPE_UNICODE;
+                    val.StrVal = BlobType.createFromString(val.StrVal, contentType);
+                    val.IncludeBlobPrefix = true;
+                    val.Attr = expectedType;
+                }
+            }
+        }
+    }
+    eval_op_zimeread(resVal) {
+        resVal.Attr = StorageAttribute.ALPHA;
+        resVal.StrVal = '';
+        let utilImeJpn = Manager.UtilImeJpn;
+        if (utilImeJpn !== null) {
+            let strImeRead = utilImeJpn.StrImeRead;
+            if (!NString.IsNullOrEmpty(utilImeJpn.StrImeRead)) {
+                resVal.StrVal = strImeRead;
+            }
+        }
+    }
+    ConvertExpVal(val, expectedType) {
+        if (StorageAttributeCheck.StorageFldAlphaUnicodeOrBlob(val.Attr, expectedType)) {
+            this.BlobStringConversion(val, expectedType);
+        }
+    }
+}
+export class ExpVal {
+    Attr = StorageAttribute.NONE;
+    IsNull = false;
+    MgNumVal = null;
+    StrVal = null;
+    BoolVal = false;
+    IncludeBlobPrefix = false;
+    OriginalNull = false;
+    VectorField = null;
+    constructor(attr, isNull, mgVal) {
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        this.constructor_1(attr, isNull, mgVal);
+    }
+    constructor_0() {
+        this.Attr = StorageAttribute.NONE;
+    }
+    constructor_1(attr, isNull, mgVal) {
+        this.Init(attr, isNull, mgVal);
+    }
+    Copy(src) {
+        this.Attr = src.Attr;
+        this.BoolVal = src.BoolVal;
+        this.IncludeBlobPrefix = src.IncludeBlobPrefix;
+        this.IsNull = src.IsNull;
+        this.MgNumVal = src.MgNumVal;
+        this.StrVal = src.StrVal;
+        this.VectorField = src.VectorField;
+        this.OriginalNull = src.OriginalNull;
+    }
+    Nullify() {
+        this.Init(StorageAttribute.NONE, true, null);
+    }
+    Init(attr, isNull, mgVal) {
+        this.Attr = attr;
+        this.IsNull = isNull;
+        switch (this.Attr) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+                this.StrVal = mgVal;
+                break;
+            case StorageAttribute.BLOB:
+            case StorageAttribute.BLOB_VECTOR:
+                this.StrVal = mgVal;
+                this.IncludeBlobPrefix = true;
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                this.MgNumVal = ((mgVal !== null) ? new NUM_TYPE(mgVal) : null);
+                break;
+            case StorageAttribute.BOOLEAN:
+                this.BoolVal = (mgVal !== null && mgVal === '1');
+                break;
+            case StorageAttribute.NONE:
+                this.BoolVal = false;
+                this.StrVal = null;
+                this.MgNumVal = null;
+                this.OriginalNull = true;
+                this.VectorField = null;
+                this.IncludeBlobPrefix = false;
+                break;
+            case StorageAttribute.DOTNET:
+                this.StrVal = mgVal;
+                break;
+            default:
+                throw new ApplicationException('in ExpVal.ExpVal() illegal attribute: \'' + this.Attr + '\'');
+        }
+    }
+    ToMgVal() {
+        let str;
+        switch (this.Attr) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.BLOB:
+            case StorageAttribute.BLOB_VECTOR:
+            case StorageAttribute.UNICODE:
+                str = this.StrVal;
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                str = this.MgNumVal.toXMLrecord();
+                break;
+            case StorageAttribute.BOOLEAN:
+                str = this.BoolVal
+                    ? '1'
+                    : '0';
+                break;
+            default:
+                str = '[illegal attribute: ' + this.Attr + ']';
+                break;
+        }
+        return str;
+    }
+    isEmptyString() {
+        return (this.Attr === StorageAttribute.ALPHA || this.Attr === StorageAttribute.UNICODE) && this.StrVal === '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GuiExpressionEvaluator.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/exp/GuiExpressionEvaluator.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationException, NString} from '@magic-xpa/mscorelib';\r\nimport {Rtf, StorageAttribute, StorageAttributeCheck, StrUtil, UtilImeJpn} from '@magic-xpa/utils';\r\nimport {GuiTaskBase} from '../tasks/GuiTaskBase';\r\nimport {ITask} from '../tasks/ITask';\r\nimport {Manager} from '../../Manager';\r\nimport {MgControlBase} from '../gui/MgControlBase';\r\nimport {NUM_TYPE} from '../data/NUM_TYPE';\r\nimport {GuiFieldBase} from '../data/GuiFieldBase';\r\n\r\nimport {BlobType} from '../data/BlobType';\r\nimport {ValidationDetails} from '../gui/ValidationDetails';\r\nimport {PIC} from '../gui/PIC';\r\nimport {DisplayConvertor} from '../gui/DisplayConvertor';\r\n\r\n\r\nexport abstract class GuiExpressionEvaluator {\r\n  static TRIGGER_TASK: number = 500000;\r\n  ExpTask: GuiTaskBase = null;\r\n  private Events: any = null;\r\n\r\n\r\n  abstract HandleControlGoto(task: ITask, ctrl: MgControlBase, rowNo: number): boolean;\r\n\r\n\r\n  /// <summary>(protected)\r\n  /// sets the status bar text with the given text and\r\n  /// sets the result with the last text that was set to the status bar by the use of this function\r\n  /// </summary>\r\n  /// <param name = \"resVal\">last text of status bar</param>\r\n  /// <param name = \"statusBarText\">the text to be set at status bar</param>\r\n  eval_op_statusbar_set_text(resVal: ExpVal, statusBarText: ExpVal): void {\r\n    resVal.Attr = StorageAttribute.UNICODE;\r\n    resVal.StrVal = Manager.GetCurrentRuntimeContext().DefaultStatusMsg;\r\n\r\n    if (Manager.GetCurrentRuntimeContext().DefaultStatusMsg === null) {\r\n      resVal.StrVal = '';\r\n    } else {\r\n      resVal.StrVal = Manager.GetCurrentRuntimeContext().DefaultStatusMsg;\r\n    }\r\n    resVal.IsNull = false;\r\n\r\n    if (!(statusBarText.Attr !== StorageAttribute.ALPHA && statusBarText.Attr !== StorageAttribute.UNICODE)) {\r\n      if (!statusBarText.IsNull) {\r\n        let text: string = statusBarText.StrVal;\r\n        let task: GuiTaskBase = <GuiTaskBase>this.ExpTask.GetContextTask();\r\n\r\n        // In case of non interactive tasks, it is possible that task has open window = No, So display the status bar msg on frame window.\r\n        if (task.getForm() === null && Manager.GetCurrentRuntimeContext().FrameForm !== null) {\r\n          task = Manager.GetCurrentRuntimeContext().FrameForm.getTask();\r\n        }\r\n        task.WriteToMessagePane(text);\r\n        Manager.GetCurrentRuntimeContext().DefaultStatusMsg = text;\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  IsParallel(): boolean {\r\n    return false;\r\n  }\r\n\r\n\r\n  /// <summary>(protected)\r\n  /// return the control name of last clicked control\r\n  /// </summary>\r\n  eval_op_ctrl_name(resVal: ExpVal): void {\r\n    let lastClickedCtrlName: string = Manager.GetCurrentRuntimeContext().LastClickedCtrlName;\r\n    resVal.StrVal = (NString.IsNullOrEmpty(lastClickedCtrlName) ? '' : lastClickedCtrlName);\r\n    resVal.Attr = StorageAttribute.ALPHA;\r\n  }\r\n\r\n\r\n  /// <summary>(protected)\r\n  /// Moves the caret to specified control\r\n  /// </summary>\r\n  /// <param name = \"ctrlName\">the name of the destination control</param>\r\n  /// <param name = \"rowNum\">the row in the table  0 represents current row</param>\r\n  /// <param name = \"generation\">the task generation</param>\r\n  /// <param name = \"retVal\">the result</param>\r\n  eval_op_gotoCtrl(ctrlName: ExpVal, rowNum: ExpVal, generation: ExpVal, retVal: ExpVal): void {\r\n    retVal.Attr = StorageAttribute.BOOLEAN;\r\n    retVal.BoolVal = false;\r\n    let task: GuiTaskBase = this.GetContextTask(generation.MgNumVal.NUM_2_LONG());\r\n    if (task === null || task.getForm() === null)\r\n      return;\r\n\r\n    let iRowNum: number = rowNum.MgNumVal.NUM_2_LONG();\r\n    let sCtrlName: string = StrUtil.rtrim(ctrlName.StrVal);\r\n    let ctrl: MgControlBase = task.getForm().GetCtrl(sCtrlName);\r\n    retVal.BoolVal = this.HandleControlGoto(task, ctrl, iRowNum);\r\n  }\r\n\r\n  /// <summary>(protected)\r\n  /// get context task by a specified generation\r\n  /// </summary>\r\n  /// <param name = \"currTask\">current task</param>\r\n  /// <param name = \"generation\">task generation</param>\r\n  /// <returns> task at specified generation</returns>\r\n  static GetContextTask(currTask: GuiTaskBase, generation: number): GuiTaskBase {\r\n    let task: GuiTaskBase = null;\r\n    let taskBase: GuiTaskBase = <GuiTaskBase> currTask.GetContextTask();\r\n    if (generation === GuiExpressionEvaluator.TRIGGER_TASK) {\r\n      task = taskBase;\r\n    } else {\r\n      if (generation < taskBase.GetTaskDepth()) {\r\n        task = <GuiTaskBase>taskBase.GetTaskAncestor(generation);\r\n      }\r\n    }\r\n    return task;\r\n  }\r\n\r\n  /// <summary>(protected)\r\n  /// get context task by a specified generation\r\n  /// </summary>\r\n  /// <param name = \"generation\">task generation</param>\r\n  /// <returns> task at specified generation</returns>\r\n  GetContextTask(generation: number): GuiTaskBase {\r\n    return GuiExpressionEvaluator.GetContextTask(this.ExpTask, generation);\r\n  }\r\n\r\n  /// <summary>(protected)\r\n  /// Create a NUM_TYPE with the value of i and set the ExpVal with it\r\n  /// </summary>\r\n  ConstructMagicNum(resVal: ExpVal, i: number, attr: StorageAttribute): void {\r\n    resVal.MgNumVal = new NUM_TYPE();\r\n    resVal.MgNumVal.NUM_4_LONG(i);\r\n    resVal.Attr = attr;\r\n  }\r\n\r\n  /// <summary>(public)\r\n  /// set null value to Expression Evaluator\r\n  /// </summary>\r\n  /// <param name = \"resVal\">to set it NULL</param>\r\n  /// <param name = \"attr\">attribute of ExpValue</param>\r\n  SetNULL(resVal: ExpVal, attr: StorageAttribute): void {\r\n    resVal.IsNull = true;\r\n    resVal.Attr = attr;\r\n\r\n    switch (attr) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n        resVal.StrVal = null;\r\n        break;\r\n\r\n      case StorageAttribute.TIME:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.NUMERIC:\r\n        resVal.MgNumVal = null;\r\n        break;\r\n\r\n      case StorageAttribute.BOOLEAN:\r\n        resVal.BoolVal = false;\r\n        break;\r\n\r\n      default:\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   validate value of the control\r\n  /// </summary>\r\n  /// <param name = \"currCtrl\">control whose value need to be evaluated</param>\r\n  /// <param name = \"oldValue\">old value of the control</param>\r\n  /// <param name = \"newValue\">new value of the control</param>\r\n  GetValidatedValue(currCtrl: MgControlBase, oldValue: string, newValue: string): string {\r\n    let vd: ValidationDetails = currCtrl.buildCopyPicture(oldValue, newValue);\r\n    vd.evaluate();\r\n    let validationFailed: boolean = vd.ValidationFailed;\r\n    let ctrlValue: string;\r\n    if (validationFailed) {\r\n      let field: GuiFieldBase = currCtrl.getField();\r\n      ctrlValue = ((field.getType() === StorageAttribute.BLOB_VECTOR) ? field.getCellDefualtValue() : field.getDefaultValue());\r\n    } else {\r\n      ctrlValue = vd.getDispValue();\r\n    }\r\n    return ctrlValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set expValue of needed type . the value is inited by value\r\n  /// </summary>\r\n  /// <param name = \"resVal\">need be evaluated/initialized</param>\r\n  /// <param name = \"type\">of resVal (Alpha|Numeric|Logical|Date|Time|Blob|Vector)</param>\r\n  /// <param name = \"val\">string/hexa string</param>\r\n  /// <param name = \"pic\">for string evaluation</param>\r\n  SetVal(resVal: ExpVal, type: StorageAttribute, val: string, pic: PIC): void {\r\n\r\n    switch (type) {\r\n\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.BLOB:\r\n      case StorageAttribute.BLOB_VECTOR:\r\n      case StorageAttribute.UNICODE:\r\n        resVal.Attr = type;\r\n        resVal.StrVal = val;\r\n\r\n        if (type === StorageAttribute.BLOB || type === StorageAttribute.BLOB_VECTOR)\r\n          resVal.IncludeBlobPrefix = true;\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        resVal.Attr = type;\r\n        if (val == null)\r\n          resVal.MgNumVal = null;\r\n        else if (pic == null)\r\n          resVal.MgNumVal = new NUM_TYPE(val);\r\n        else\r\n          resVal.MgNumVal = new NUM_TYPE(val, pic, (this.ExpTask).getCompIdx());\r\n        break;\r\n\r\n      case StorageAttribute.BOOLEAN:\r\n        resVal.Attr = type;\r\n        resVal.BoolVal = DisplayConvertor.toBoolean(val);\r\n        break;\r\n\r\n      default:\r\n        this.SetNULL(resVal, type);\r\n\r\n        this.Events.WriteExceptionToLog('ExpressionEvaluator.SetVal() there is no such type : ' + type);\r\n\r\n        // ClientManager.Instance.WriteErrorToLog(\"ExpressionEvaluator.SetVal() there is no such type : \" + type);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>(protected)\r\n  /// trims and returns the string.\r\n  /// </summary>\r\n  /// <param name = \"val\">containing string to be trimmed (strVal_ member of ExpVal)</param>\r\n  /// <returns>trimmed string</returns>\r\n  static exp_build_string(val: ExpVal): string {\r\n    let name: string = '';\r\n    if (val.StrVal !== null) {\r\n      let len: number = <number>val.StrVal.length;\r\n      if (len > 0) {\r\n        name = StrUtil.ZstringMake(val.StrVal, <number>len);\r\n      }\r\n    }\r\n    return name;\r\n  }\r\n\r\n  /// <summary>\r\n  /// checks if the object is instance of ExpVal\r\n  /// </summary>\r\n  /// <param name=\"obj\"></param>\r\n  /// <returns></returns>\r\n  static isExpVal(obj: any): boolean {\r\n    return obj instanceof ExpVal;\r\n  }\r\n\r\n  /// <summary>(private)\r\n  /// handle conversions between blob and unicode/alpha\r\n  /// </summary>\r\n  /// <param name=\"val\"></param>\r\n  /// <param name=\"expectedType\"></param>\r\n  private BlobStringConversion(val: ExpVal, expectedType: StorageAttribute): void {\r\n    if (StorageAttributeCheck.IsTypeAlphaOrUnicode(expectedType)) {\r\n      if (val.Attr === StorageAttribute.BLOB) {\r\n        let includeBlobPrefix: boolean = val.IncludeBlobPrefix;\r\n        if (includeBlobPrefix) {\r\n          let contentType: string = BlobType.getContentType(val.StrVal);\r\n          val.StrVal = BlobType.getString(val.StrVal);\r\n          val.IncludeBlobPrefix = false;\r\n          if (contentType !== BlobType.CONTENT_TYPE_BINARY && Rtf.isRtf(val.StrVal)) {\r\n            val.StrVal = StrUtil.GetPlainTextfromRtf(val.StrVal);\r\n          }\r\n        }\r\n        val.Attr = expectedType;\r\n      } else {\r\n        if (val.Attr === StorageAttribute.BLOB_VECTOR) {\r\n          let includeBlobPrefix2: boolean = val.IncludeBlobPrefix;\r\n          if (includeBlobPrefix2) {\r\n            val.StrVal = BlobType.removeBlobPrefix(val.StrVal);\r\n            val.IncludeBlobPrefix = false;\r\n          }\r\n          val.Attr = expectedType;\r\n        }\r\n      }\r\n    } else {\r\n      if (expectedType === StorageAttribute.BLOB) {\r\n        if (StorageAttributeCheck.IsTypeAlphaOrUnicode(val.Attr)) {\r\n          let contentType: string = (val.Attr === StorageAttribute.ALPHA) ? BlobType.CONTENT_TYPE_ANSI : BlobType.CONTENT_TYPE_UNICODE;\r\n          val.StrVal = BlobType.createFromString(val.StrVal, contentType);\r\n          val.IncludeBlobPrefix = true;\r\n          val.Attr = expectedType;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  eval_op_zimeread(resVal: ExpVal): void {\r\n    resVal.Attr = StorageAttribute.ALPHA;\r\n    resVal.StrVal = '';\r\n    let utilImeJpn: UtilImeJpn = Manager.UtilImeJpn;\r\n    if (utilImeJpn !== null) {\r\n      let strImeRead: string = utilImeJpn.StrImeRead;\r\n      if (!NString.IsNullOrEmpty(utilImeJpn.StrImeRead)) {\r\n        resVal.StrVal = strImeRead;\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n\r\n  ConvertExpVal(val: ExpVal, expectedType: StorageAttribute): void {\r\n    if (StorageAttributeCheck.StorageFldAlphaUnicodeOrBlob(val.Attr, expectedType)) {\r\n      this.BlobStringConversion(val, expectedType);\r\n    }\r\n  }\r\n\r\n\r\n}\r\n\r\n/// <summary>\r\n///   The class holds data of a basic element (constant or variable) that\r\n///   appears or are result of execution of operator\r\n/// </summary>\r\nexport class ExpVal {\r\n  Attr: StorageAttribute = StorageAttribute.NONE;\r\n  IsNull: boolean = false;\r\n  MgNumVal: NUM_TYPE = null;\r\n  StrVal: string = null;\r\n  BoolVal: boolean = false;\r\n  IncludeBlobPrefix: boolean = false;\r\n  OriginalNull: boolean = false;\r\n  VectorField: GuiFieldBase = null;\r\n\r\n  constructor();\r\n  constructor(attr: StorageAttribute, isNull: boolean, mgVal: string);\r\n  constructor(attr?: StorageAttribute, isNull?: boolean, mgVal?: string) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    this.constructor_1(attr, isNull, mgVal);\r\n  }\r\n\r\n  private constructor_0(): void {\r\n    this.Attr = StorageAttribute.NONE;\r\n  }\r\n\r\n  private constructor_1(attr: StorageAttribute, isNull: boolean, mgVal: string): void {\r\n    this.Init(attr, isNull, mgVal);\r\n  }\r\n\r\n  Copy(src: ExpVal): void {\r\n    this.Attr = src.Attr;\r\n    this.BoolVal = src.BoolVal;\r\n    this.IncludeBlobPrefix = src.IncludeBlobPrefix;\r\n    this.IsNull = src.IsNull;\r\n    this.MgNumVal = src.MgNumVal;\r\n    this.StrVal = src.StrVal;\r\n    this.VectorField = src.VectorField;\r\n    this.OriginalNull = src.OriginalNull;\r\n  }\r\n\r\n  /// <summary>\r\n  /// nullify\r\n  /// </summary>\r\n  Nullify(): void {\r\n    this.Init(StorageAttribute.NONE, true, null);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   initialize\r\n  /// </summary>\r\n  Init(attr: StorageAttribute, isNull: boolean, mgVal: string): void {\r\n    this.Attr = attr;\r\n    this.IsNull = isNull;\r\n\r\n\r\n    switch (this.Attr) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n        this.StrVal = mgVal;\r\n        break;\r\n\r\n      case StorageAttribute.BLOB:\r\n      case StorageAttribute.BLOB_VECTOR:\r\n        this.StrVal = mgVal;\r\n        this.IncludeBlobPrefix = true;\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        this.MgNumVal = ((mgVal !== null) ? new NUM_TYPE(mgVal) : null);\r\n        break;\r\n\r\n      case StorageAttribute.BOOLEAN:\r\n        this.BoolVal = (mgVal !== null && mgVal === '1');\r\n        break;\r\n\r\n      case StorageAttribute.NONE:\r\n        this.BoolVal = false;\r\n        this.StrVal = null;\r\n        this.MgNumVal = null;\r\n        this.OriginalNull = true;\r\n        this.VectorField = null;\r\n        this.IncludeBlobPrefix = false;\r\n        break;\r\n\r\n      case StorageAttribute.DOTNET:\r\n        // For dotnet objects, ExpVal should be constructed using overloaded Constructor.\r\n        // If it is a blobPrefix, it should be done here.\r\n        this.StrVal = mgVal;\r\n        break;\r\n\r\n      default:\r\n        throw new ApplicationException('in ExpVal.ExpVal() illegal attribute: \\'' + this.Attr + '\\'');\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Gets the string form of the value in the ExpVal class\r\n  /// </summary>\r\n  ToMgVal(): string {\r\n\r\n    let str: string;\r\n\r\n    switch (this.Attr) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.BLOB:\r\n      case StorageAttribute.BLOB_VECTOR:\r\n      case StorageAttribute.UNICODE:\r\n        str = this.StrVal;\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        str = this.MgNumVal.toXMLrecord();\r\n        break;\r\n\r\n      case StorageAttribute.BOOLEAN:\r\n        str = this.BoolVal\r\n          ? '1'\r\n          : '0';\r\n        break;\r\n\r\n      default:\r\n        str = '[illegal attribute: ' + this.Attr + ']';\r\n        break;\r\n    }\r\n    return str;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return true if the value is an empty string\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isEmptyString(): boolean {\r\n    return (this.Attr === StorageAttribute.ALPHA || this.Attr === StorageAttribute.UNICODE) && this.StrVal === '';\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/src/management/gui/ControlTable.mjs

@@ -0,0 +1,118 @@
+import { XMLConstants } from '@magic-xpa/utils';
+import { MgControlBase } from './MgControlBase';
+import { List, NString } from '@magic-xpa/mscorelib';
+export class ControlTable {
+    _controls = null;
+    _mgForm = null;
+    constructor() {
+        this._controls = new List();
+    }
+    fillData(mgForm, parser) {
+        this._mgForm = mgForm;
+        while (this.initInnerObjects(parser.getNextTag(), parser)) {
+        }
+    }
+    initInnerObjects(foundTagName, parser) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === XMLConstants.MG_TAG_CONTROL) {
+            let control = this._mgForm.ConstructMgControl();
+            control.fillData(this._mgForm, this._controls.length, parser);
+            this._controls.push(control);
+        }
+        else if (foundTagName === ("/" + XMLConstants.MG_TAG_CONTROL)) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else
+            return false;
+        return true;
+    }
+    getSize() {
+        return this._controls.length;
+    }
+    getCtrl(idxOrCtrlName) {
+        if (arguments.length === 1 && (idxOrCtrlName === null || typeof idxOrCtrlName === "undefined" || idxOrCtrlName.constructor === Number)) {
+            return this.getCtrl_0(idxOrCtrlName);
+        }
+        return this.getCtrl_1(idxOrCtrlName);
+    }
+    getCtrl_0(idx) {
+        if (idx < this.getSize())
+            return this._controls.get_Item(idx);
+        return null;
+    }
+    getCtrl_1(ctrlName) {
+        if (!NString.IsNullOrEmpty(ctrlName)) {
+            return this._controls.find(ctrl => {
+                return (NString.Equals(ctrlName, ctrl.getName(), true) ||
+                    NString.Equals(ctrlName, ctrl.Name, true));
+            });
+        }
+        return null;
+    }
+    getCtrlByName(ctrlName, ctrlType) {
+        if (!NString.IsNullOrEmpty(ctrlName)) {
+            return this._controls.find(ctrl => {
+                return ((ctrl.Type === ctrlType) && NString.Equals(ctrlName, ctrl.getName(), true) ||
+                    NString.Equals(ctrlName, ctrl.Name, true));
+            });
+        }
+        return null;
+    }
+    GetControlByIsn(isn) {
+        let ctrlByIsn = null;
+        ctrlByIsn = this._controls.find(ctrl => {
+            return (ctrl.ControlIsn === isn);
+        });
+        return ctrlByIsn;
+    }
+    GetControl(predicate) {
+        return this._controls.find(predicate);
+    }
+    filter(callackFuntion) {
+        return this._controls.filter(callackFuntion);
+    }
+    contains(ctrl) {
+        let contains = false;
+        if (ctrl !== null)
+            contains = this._controls.Contains(ctrl);
+        return contains;
+    }
+    addControl(ctrl) {
+        this._controls.push(ctrl);
+    }
+    setControlAt(ctrl, index) {
+        if (this._controls.length <= index)
+            this._controls.SetSize(index + 1);
+        this._controls.set_Item(index, ctrl);
+    }
+    deleteControlAt(index) {
+        this._controls.set_Item(index, null);
+    }
+    Remove(ctrlOrIdx) {
+        if (arguments.length === 1 && (ctrlOrIdx === null || ctrlOrIdx instanceof MgControlBase)) {
+            return this.Remove_0(ctrlOrIdx);
+        }
+        this.Remove_1(ctrlOrIdx);
+    }
+    Remove_0(ctrl) {
+        this._controls.Remove(ctrl);
+        return this._controls.Contains(ctrl);
+    }
+    Remove_1(idx) {
+        this._controls.RemoveAt(idx);
+    }
+    getControlIdx(inCtrl, includeSubs) {
+        let counter = 0;
+        for (let i = 0; i < this._controls.length; i++) {
+            let ctrl = this._controls.get_Item(i);
+            if (inCtrl === ctrl)
+                return counter;
+            else if (includeSubs || !ctrl.isSubform())
+                counter++;
+        }
+        return -1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ControlTable.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/gui/ControlTable.ts"],"names":[],"mappings":"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","sourcesContent":["import { MgControlType, XMLConstants, XmlParser } from '@magic-xpa/utils';\r\nimport { MgFormBase } from './MgFormBase';\r\nimport { MgControlBase } from './MgControlBase';\r\nimport { List, NString } from '@magic-xpa/mscorelib';\r\n\r\nexport class ControlTable {\r\n  private _controls: List<MgControlBase> = null;\r\n  private _mgForm: MgFormBase = null;\r\n\r\n  /// <summary>CTOR</summary>\r\n  constructor() {\r\n    this._controls = new List();\r\n  }\r\n\r\n  /// <summary>parse input string and fill inner data</summary>\r\n  fillData(mgForm: MgFormBase, parser: XmlParser): void {\r\n\r\n    this._mgForm = mgForm;\r\n    while (this.initInnerObjects(parser.getNextTag(), parser)) {\r\n    }\r\n  }\r\n\r\n  /// <summary>To allocate and fill inner objects of the class</summary>\r\n  /// <param name = \"foundTagName\">name of tag, of object, which need be allocated</param>\r\n  /// <returns> boolean if inner tags finished</returns>\r\n  private initInnerObjects(foundTagName: string, parser: XmlParser): boolean {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    if (foundTagName === XMLConstants.MG_TAG_CONTROL) {\r\n      let control: MgControlBase = this._mgForm.ConstructMgControl();\r\n      control.fillData(this._mgForm, this._controls.length, parser);\r\n      this._controls.push(control);\r\n    }\r\n    else if (foundTagName === (\"/\" + XMLConstants.MG_TAG_CONTROL)) {\r\n        parser.setCurrIndex2EndOfTag();\r\n        return false;\r\n    }\r\n    else\r\n      return false;\r\n\r\n    return true;\r\n  }\r\n\r\n  /// <summary>get the size of the table</summary>\r\n  /// <returns> the size of the table</returns>\r\n  getSize(): number {\r\n    return this._controls.length;\r\n  }\r\n\r\n  getCtrl(idx: number): MgControlBase;\r\n  getCtrl(ctrlName: string): MgControlBase;\r\n  getCtrl(idxOrCtrlName: any): MgControlBase {\r\n    if (arguments.length === 1 && (idxOrCtrlName === null || typeof idxOrCtrlName === \"undefined\" || idxOrCtrlName.constructor === Number)) {\r\n      return this.getCtrl_0(idxOrCtrlName);\r\n    }\r\n    return this.getCtrl_1(idxOrCtrlName);\r\n  }\r\n\r\n  /// <summary>get control by its index</summary>\r\n  /// <param name = \"idx\">is the index of the control in the table</param>\r\n  /// <returns> the requested control object</returns>\r\n  private getCtrl_0(idx: number): MgControlBase {\r\n    if (idx < this.getSize())\r\n      return this._controls.get_Item(idx);\r\n\r\n    return null;\r\n  }\r\n\r\n\r\n  /// <summary>get control by its name</summary>\r\n  /// <param name = \"ctrlName\">is the requested controls name</param>\r\n  /// <returns> the requested control object</returns>\r\n  private getCtrl_1(ctrlName: string): MgControlBase {\r\n    if (!NString.IsNullOrEmpty(ctrlName)) {\r\n\r\n      return this._controls.find(ctrl => {\r\n        return (NString.Equals(ctrlName, ctrl.getName(), true) ||\r\n          NString.Equals(ctrlName, ctrl.Name, true));\r\n      });\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /// <summary>get control (which is not the frame form) by its name</summary>\r\n  /// <param name = \"ctrlName\">is the requested controls name</param>\r\n  /// <param name=\"ctrlType\"></param>\r\n  /// <returns> the requested control object</returns>\r\n  getCtrlByName(ctrlName: string, ctrlType: MgControlType): MgControlBase {\r\n    if (!NString.IsNullOrEmpty(ctrlName)) {\r\n      return this._controls.find(ctrl => {\r\n        return ((ctrl.Type === ctrlType) && NString.Equals(ctrlName, ctrl.getName(), true) ||\r\n          NString.Equals(ctrlName, ctrl.Name, true))\r\n      });\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  /// get a control by its ISN\r\n  /// </summary>\r\n  /// <param name=\"isn\"></param>\r\n  /// <returns></returns>\r\n  GetControlByIsn(isn: number): MgControlBase {\r\n    let ctrlByIsn: MgControlBase = null;\r\n    ctrlByIsn = this._controls.find(ctrl => {\r\n      return (ctrl.ControlIsn === isn)\r\n    });\r\n\r\n    return ctrlByIsn;\r\n  }\r\n\r\n  /// <summary>\r\n  /// get a control mathching the predicate\r\n  /// </summary>\r\n  /// <param name=\"predicate\"></param>\r\n  /// <returns></returns>\r\n  GetControl(predicate: (value: MgControlBase) => boolean): MgControlBase {\r\n    return this._controls.find(predicate);\r\n  }\r\n\r\n  public filter(callackFuntion: (item, index, array) => boolean): any {\r\n    return this._controls.filter(callackFuntion);\r\n\r\n  }\r\n\r\n  /// <summary>returns true if this table contains the given control</summary>\r\n  /// <param name = \"ctrl\">the control to look for</param>\r\n  contains(ctrl: MgControlBase): boolean {\r\n    let contains: boolean = false;\r\n    if (ctrl !== null)\r\n      contains = this._controls.Contains(ctrl);\r\n    return contains;\r\n  }\r\n\r\n  /// <summary>add a control to the table</summary>\r\n  /// <param name = \"ctrl\">is the control to be added</param>\r\n  addControl(ctrl: MgControlBase): void {\r\n    this._controls.push(ctrl);\r\n  }\r\n\r\n  /// <summary>set a control to a cell in the table</summary>\r\n  /// <param name = \"ctrl\">is the control to be added</param>\r\n  /// <param name = \"index\">where to set the control</param>\r\n  setControlAt(ctrl: MgControlBase, index: number): void {\r\n    if (this._controls.length <= index)\r\n      this._controls.SetSize(index + 1);\r\n    this._controls.set_Item(index, ctrl);\r\n  }\r\n\r\n  /// <summary>replace a control in the control table with null</summary>\r\n  /// <param name = \"index\">of control to be deleted</param>\r\n  deleteControlAt(index: number): void {\r\n    this._controls.set_Item(index, null);\r\n  }\r\n\r\n  Remove(ctrl: MgControlBase): boolean;\r\n  Remove(idx: number);\r\n  Remove(ctrlOrIdx: any): boolean {\r\n    if (arguments.length === 1 && (ctrlOrIdx === null || ctrlOrIdx instanceof MgControlBase)) {\r\n      return this.Remove_0(ctrlOrIdx);\r\n    }\r\n    this.Remove_1(ctrlOrIdx);\r\n  }\r\n\r\n  /// <summary>removes a control from the table and returns true on success</summary>\r\n  /// <param name = \"ctrl\">the control to remove</param>\r\n  private Remove_0(ctrl: MgControlBase): boolean {\r\n    this._controls.Remove(ctrl);\r\n    return this._controls.Contains(ctrl);\r\n  }\r\n\r\n  /// <summary>removes a control from the table by index.</summary>\r\n  /// <param name = \"idx\">the idx of the control to be removed</param>\r\n  private Remove_1(idx: number): void {\r\n    this._controls.RemoveAt(idx);\r\n  }\r\n\r\n  /// <param name = \"inCtrl\">the control whose index we need</param>\r\n  /// <param name=\"includeSubs\"></param>\r\n  /// <returns> idx of a control in the table, excluding subforms control</returns>\r\n  getControlIdx(inCtrl: MgControlBase, includeSubs: boolean): number {\r\n    let counter: number = 0;\r\n    for (let i: number = 0; i < this._controls.length; i++) {\r\n      let ctrl: MgControlBase = this._controls.get_Item(i);\r\n      if (inCtrl === ctrl)\r\n        return counter;\r\n      else if (includeSubs || !ctrl.isSubform())\r\n        counter++;\r\n    }\r\n    return -1;\r\n  }\r\n\r\n\r\n}\r\n"]}