@magic-xpa/gui 4.1100.0-dev4110.25 → 4.1100.0-dev4110.252

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

@@ -0,0 +1,1649 @@
+import { PIC } from './PIC';
+import { DateTime, NString, RefParam, StringBuilder } from '@magic-xpa/mscorelib';
+import { DateUtil, HTML_2_STR, MsgInterface, PICInterface, SEQ_2_HTML, StorageAttribute, StrUtil, UtilDateJpn, UtilStrByteMode } from '@magic-xpa/utils';
+import { BlobType } from '../data/BlobType';
+import { ValidationDetailsBase } from './ValidationDetailsBase';
+import { NUM_TYPE } from '../data/NUM_TYPE';
+import { HebrewDate } from './HebrewDate';
+import { Events } from '../../Events';
+import { GuiEnvironment } from '../../GuiEnvironment';
+import { MemoryUtil } from '../../util/MemoryUtil';
+export class DisplayConvertor {
+    _environment = null;
+    DATECHAR = 0;
+    static _instance = null;
+    static get Instance() {
+        if (DisplayConvertor._instance === null) {
+            DisplayConvertor._instance = new DisplayConvertor();
+        }
+        return DisplayConvertor._instance;
+    }
+    constructor() {
+        this._environment = GuiEnvironment.Environment;
+    }
+    getNewDateBreakParams() {
+        return new DateBreakParams();
+    }
+    getNewTimeBreakParams() {
+        return new TimeBreakParams();
+    }
+    mg2disp(mgValue, rangeStr, pic, useNative, compIdxOrAlwaysFill, time_date_pic_Z_edtOrCompIdx, time_date_pic_Z_edtOrConvertCase, time_date_num_pic_Z_edt) {
+        if (arguments.length === 6)
+            return this.mg2disp_0(mgValue, rangeStr, pic, useNative, compIdxOrAlwaysFill, time_date_pic_Z_edtOrCompIdx);
+        else if (arguments.length === 7)
+            return this.mg2disp_1(mgValue, rangeStr, pic, useNative, compIdxOrAlwaysFill, time_date_pic_Z_edtOrCompIdx, time_date_pic_Z_edtOrConvertCase);
+        else
+            return this.mg2disp_2(mgValue, rangeStr, pic, useNative, compIdxOrAlwaysFill, time_date_pic_Z_edtOrCompIdx, time_date_pic_Z_edtOrConvertCase, time_date_num_pic_Z_edt);
+    }
+    mg2disp_0(mgValue, rangeStr, pic, useNative, compIdx, time_date_pic_Z_edt) {
+        return this.mg2disp(mgValue, rangeStr, pic, useNative, false, compIdx, time_date_pic_Z_edt);
+    }
+    mg2disp_1(mgValue, rangeStr, pic, useNative, alwaysFill, compIdx, time_date_pic_Z_edt) {
+        return this.mg2disp(mgValue, rangeStr, pic, useNative, alwaysFill, compIdx, false, time_date_pic_Z_edt);
+    }
+    mg2disp_2(mgValue, rangeStr, pic, useNative, alwaysFill, compIdx, convertCase, time_date_num_pic_Z_edt) {
+        let str = "";
+        let tmpRange = (rangeStr === null) ? "" : rangeStr;
+        switch (pic.getAttr()) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+                str = this.fromAlpha(mgValue, pic, tmpRange, alwaysFill, convertCase);
+                break;
+            case StorageAttribute.NUMERIC: {
+                let newPic = pic.getUnformattedNumericPic();
+                let dec = GuiEnvironment.Environment.GetDecimal();
+                let thou = GuiEnvironment.Environment.GetThousands();
+                GuiEnvironment.Environment.setDecimalSeparator('.');
+                GuiEnvironment.Environment.setThousandsSeparator(',');
+                str = this.fromNum(mgValue, newPic);
+                GuiEnvironment.Environment.setDecimalSeparator(dec);
+                GuiEnvironment.Environment.setThousandsSeparator(thou);
+                if (newPic.getMaskChars() === 0 || !time_date_num_pic_Z_edt)
+                    str = StrUtil.ltrim(str);
+                if (useNative) {
+                    if (str == "")
+                        return null;
+                    let dbl = Number(str);
+                    return dbl;
+                }
+                else
+                    return str;
+            }
+            case StorageAttribute.DATE: {
+                if (useNative) {
+                    let dt;
+                    dt = this.fromMgDateToNativeDate(mgValue, pic, compIdx);
+                    return dt;
+                }
+                else {
+                    str = this.fromDate(mgValue, pic, compIdx, time_date_num_pic_Z_edt);
+                    break;
+                }
+            }
+            case StorageAttribute.TIME: {
+                if (useNative) {
+                    let dt;
+                    dt = this.fromMgTimeToNativeTime(mgValue, pic);
+                    return dt;
+                }
+                else {
+                    str = this.fromTime(mgValue, pic, time_date_num_pic_Z_edt);
+                    break;
+                }
+            }
+            case StorageAttribute.BOOLEAN: {
+                let logVal;
+                logVal = this.fromMgLogicalToNativeLogical(mgValue);
+                return logVal;
+            }
+            case StorageAttribute.BLOB:
+                str = BlobType.getString(mgValue);
+                break;
+            case StorageAttribute.BLOB_VECTOR:
+                str = mgValue;
+                break;
+        }
+        return str;
+    }
+    disp2mg(dispValue, pic, compIdx, blobContentType) {
+        let str = "";
+        switch (pic.getAttr()) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+                str = this.toAlpha(dispValue, pic);
+                break;
+            case StorageAttribute.NUMERIC:
+                {
+                    dispValue = String(dispValue);
+                    let len = dispValue.length;
+                    while (len > 0) {
+                        if (!pic.picIsMask(len - 1) && dispValue[len - 1] !== (' '))
+                            break;
+                        len--;
+                    }
+                    if (dispValue.length > len)
+                        dispValue = NString.Remove(dispValue, len, (dispValue.length - len));
+                    if (pic.isNegative() && dispValue.trim().startsWith("-"))
+                        dispValue = StrUtil.ltrim(dispValue);
+                    let dec = GuiEnvironment.Environment.GetDecimal();
+                    let thou = GuiEnvironment.Environment.GetThousands();
+                    GuiEnvironment.Environment.setDecimalSeparator('.');
+                    GuiEnvironment.Environment.setThousandsSeparator(',');
+                    let newPic = pic.getUnformattedNumericPic();
+                    str = this.toNum(dispValue, newPic, compIdx);
+                    GuiEnvironment.Environment.setDecimalSeparator(dec);
+                    GuiEnvironment.Environment.setThousandsSeparator(thou);
+                }
+                break;
+            case StorageAttribute.DATE:
+                {
+                    let dt;
+                    if (typeof dispValue === 'string')
+                        dt = new Date(dispValue);
+                    else
+                        dt = dispValue;
+                    str = this.fromNativeDateToMgDate(dt, pic);
+                }
+                break;
+            case StorageAttribute.TIME:
+                {
+                    let dt;
+                    if (typeof dispValue === 'string') {
+                        dt = new Date();
+                        if (dispValue !== null) {
+                            dt.setHours(+String(dispValue).substr(0, 2));
+                            dt.setMinutes(+String(dispValue).substr(0, 2));
+                            if (String(dispValue).length > 5)
+                                dt.setSeconds(+String(dispValue).substr(0, 2));
+                        }
+                    }
+                    else
+                        dt = dispValue;
+                    str = this.fromNativeTimeToMgTime(dt);
+                }
+                break;
+            case StorageAttribute.BOOLEAN:
+                str = this.fromNativeLogicalToMgLogical(dispValue);
+                break;
+            case StorageAttribute.BLOB:
+                str = BlobType.createFromString(dispValue, blobContentType);
+                break;
+        }
+        return str;
+    }
+    fromNum(mgValue, pic) {
+        let mgNum = new NUM_TYPE(mgValue);
+        return mgNum.toDisplayValue(pic);
+    }
+    fromAlpha(dataStr, pic, rangeStr, alwaysFill, convertCase) {
+        let len = pic.getMaskSize();
+        let min_len = len;
+        let maskStr = pic.getMask();
+        let resStr;
+        if (pic.getMaskChars() > 0) {
+            resStr = this.win_data_cpy(NString.ToCharArray(maskStr), len, NString.ToCharArray(dataStr), pic.isAttrAlpha(), convertCase);
+        }
+        else {
+            if (UtilStrByteMode.isLocaleDefLangDBCS() && pic.isAttrAlpha()) {
+                let intDataStrLenB = UtilStrByteMode.lenB(dataStr);
+                if (min_len > intDataStrLenB) {
+                    min_len = intDataStrLenB;
+                }
+                resStr = UtilStrByteMode.leftB(dataStr, min_len);
+            }
+            else if (dataStr !== null) {
+                if (min_len > dataStr.length) {
+                    min_len = dataStr.length;
+                }
+                if (convertCase) {
+                    resStr = this.win_data_cpy(NString.ToCharArray(maskStr), len, NString.ToCharArray(dataStr), pic.isAttrAlpha(), convertCase);
+                }
+                else {
+                    resStr = dataStr.substr(0, min_len);
+                }
+            }
+        }
+        if (alwaysFill || (rangeStr !== null && rangeStr.length > 0 && resStr.length < len)) {
+            let vd = new ValidationDetailsBase(rangeStr);
+            let continuousRangeValues = vd.getContinuousRangeValues();
+            let discreteRangeValues = vd.getDiscreteRangeValues();
+            if (continuousRangeValues !== null || discreteRangeValues !== null) {
+                resStr = this.fillAlphaByRange(continuousRangeValues, discreteRangeValues, resStr);
+            }
+        }
+        return resStr;
+    }
+    caseConvertedChar(data, mask) {
+        let ch;
+        if (mask.charCodeAt(0) === PICInterface.PIC_U) {
+            ch = data.toUpperCase();
+        }
+        else {
+            if (mask.charCodeAt(0) === PICInterface.PIC_L) {
+                ch = data.toLowerCase();
+            }
+            else {
+                ch = data;
+            }
+        }
+        return ch;
+    }
+    win_data_cpy(maskStr, maskLen, dataStr, isAttrAlpha, convertCase) {
+        if (arguments.length === 4)
+            return this.win_data_cpy_0(maskStr, maskLen, dataStr, isAttrAlpha);
+        return this.win_data_cpy_1(maskStr, maskLen, dataStr, isAttrAlpha, convertCase);
+    }
+    win_data_cpy_0(maskStr, maskLen, dataStr, isAttrAlpha) {
+        return this.win_data_cpy(maskStr, maskLen, dataStr, isAttrAlpha, false);
+    }
+    win_data_cpy_1(maskStr, maskLen, dataStr, isAttrAlpha, convertCase) {
+        let maskIdx = 0;
+        let dataIdx = 0;
+        let resStr = new Array(maskLen);
+        if (isAttrAlpha && UtilStrByteMode.isLocaleDefLangDBCS()) {
+            let num2 = 0;
+            while (maskIdx < maskLen && num2 < maskLen) {
+                if (maskStr[maskIdx].charCodeAt(0) <= PICInterface.PIC_MAX_OP) {
+                    if (dataIdx < dataStr.length) {
+                        let strVal = NString.FromChars(dataStr, dataIdx, 1);
+                        if (UtilStrByteMode.lenB(strVal) === 2) {
+                            if (maskIdx + 1 < maskLen) {
+                                if (maskStr[maskIdx + 1].charCodeAt(0) <= PICInterface.PIC_MAX_OP) {
+                                    if (convertCase) {
+                                        resStr[num2++] = this.caseConvertedChar(dataStr[dataIdx++], maskStr[maskIdx + 1]);
+                                    }
+                                    else {
+                                        resStr[num2++] = dataStr[dataIdx++];
+                                    }
+                                    maskIdx = maskIdx + 1;
+                                }
+                                else {
+                                    resStr[num2++] = ' ';
+                                }
+                            }
+                            else {
+                                resStr[num2++] = ' ';
+                            }
+                        }
+                        else {
+                            if (convertCase) {
+                                resStr[num2++] = this.caseConvertedChar(dataStr[dataIdx++], maskStr[maskIdx + 1]);
+                            }
+                            else {
+                                resStr[num2++] = dataStr[dataIdx++];
+                            }
+                        }
+                    }
+                    else {
+                        resStr[num2++] = ' ';
+                    }
+                }
+                else {
+                    resStr[num2++] = maskStr[maskIdx];
+                }
+                maskIdx = maskIdx + 1;
+            }
+            return NString.FromChars(resStr).substr(0, num2);
+        }
+        while (maskIdx < maskLen) {
+            if (maskStr[maskIdx].charCodeAt(0) <= PICInterface.PIC_MAX_OP) {
+                if (dataIdx < dataStr.length) {
+                    resStr[maskIdx] = dataStr[dataIdx];
+                    if (convertCase) {
+                        resStr[maskIdx] = this.caseConvertedChar(dataStr[dataIdx], maskStr[maskIdx]);
+                    }
+                    else {
+                        resStr[maskIdx] = dataStr[dataIdx];
+                    }
+                    dataIdx = dataIdx + 1;
+                }
+                else {
+                    resStr[maskIdx] = ' ';
+                }
+            }
+            else {
+                resStr[maskIdx] = maskStr[maskIdx];
+            }
+            maskIdx = maskIdx + 1;
+        }
+        return NString.FromChars(resStr);
+    }
+    fromDate(dataStr, pic, compIdx, time_date_pic_Z_edt) {
+        let mask = pic.getMask();
+        let maskSize = pic.getMaskSize();
+        let date = new NUM_TYPE(dataStr).NUM_2_ULONG();
+        return this.to_a_pic_datemode(mask, maskSize, date, pic, time_date_pic_Z_edt, false, compIdx);
+    }
+    fromTime(dataStr, pic, time_date_pic_Z_edt) {
+        let mask = pic.getMask();
+        let maskSize = pic.getMaskSize();
+        let time = new NUM_TYPE(dataStr).NUM_2_ULONG();
+        return this.time_2_a_pic(mask, maskSize, time, pic, time_date_pic_Z_edt, false);
+    }
+    fromMgDateToNativeDate(dataStr, pic, compIdx) {
+        let date = new NUM_TYPE(dataStr).NUM_2_ULONG();
+        let breakParams;
+        breakParams = new DateBreakParams();
+        this.date_break_datemode(breakParams, date, false, compIdx);
+        if (breakParams.month > 0)
+            breakParams.month = breakParams.month - 1;
+        if (breakParams.year == 0 && breakParams.month == 0 && breakParams.day == 0)
+            return null;
+        return new Date(breakParams.year, breakParams.month, breakParams.day);
+    }
+    fromNativeDateToMgDateNumber(nativeDate, pic) {
+        let numVal;
+        let dateParams;
+        let millenium = 0;
+        let year = nativeDate.getFullYear();
+        let day = nativeDate.getDate();
+        let month = nativeDate.getMonth() + 1;
+        if (pic.isHebrew()) {
+            if (year > 0) {
+                if (millenium === 0)
+                    millenium = 5;
+                year += millenium * 1000;
+            }
+            numVal = (HebrewDate.dateheb_2_d(year, month, day));
+        }
+        else {
+            if (year === 0) {
+                dateParams = this.date_sys();
+                year = dateParams.year;
+            }
+            numVal = this.date_4_calender(year, month, day, 0, false);
+        }
+        return numVal;
+    }
+    fromNativeDateToMgDate(nativeDate, pic) {
+        let mgNum = new NUM_TYPE();
+        let numVal = nativeDate == null ? 0 : this.fromNativeDateToMgDateNumber(nativeDate, pic);
+        mgNum.NUM_4_LONG(numVal);
+        return mgNum.toXMLrecord();
+    }
+    to_a_pic_datemode(outStr, out_len, date, pic, date_pic_Z_edt, ignore_dt_fmt, compIdx) {
+        let len;
+        let day = 0;
+        let doy = 0;
+        let dow = 0;
+        let year = 0;
+        let month = 0;
+        let hday = 0;
+        let hyear = 0;
+        let hmonth = 0;
+        let leap = false;
+        let i;
+        let p;
+        let outVal = NString.ToCharArray(outStr);
+        let breakParams;
+        let dateNameParams;
+        let outIdx = 0;
+        let strOut = null;
+        if (pic.getMaskSize() > out_len) {
+            for (; i < out_len; i++)
+                outVal[i] = '*';
+            return NString.FromChars(outVal);
+        }
+        out_len = len = pic.getMaskSize();
+        if (pic.zeroFill() && date === 0 && !date_pic_Z_edt) {
+            for (; i < out_len; i++)
+                outVal[i] = pic.getZeroPad();
+            return NString.FromChars(outVal);
+        }
+        if (pic.isHebrew() && (date === 0 || date === 1000000000)) {
+            for (; i < out_len; i++)
+                outVal[i] = ' ';
+            return NString.FromChars(outVal);
+        }
+        breakParams = new DateBreakParams(year, month, day, doy, dow);
+        this.date_break_datemode(breakParams, date, ignore_dt_fmt, compIdx);
+        if (pic.isHebrew()) {
+            let refhday = new RefParam(hday);
+            let refhmonth = new RefParam(hmonth);
+            let refhyear = new RefParam(hyear);
+            leap = HebrewDate.dateheb_4_d(date, refhday, refhmonth, refhyear);
+            hday = refhday.value;
+            hmonth = refhmonth.value;
+            hyear = refhyear.value;
+        }
+        year = breakParams.year;
+        month = breakParams.month;
+        day = breakParams.day;
+        doy = breakParams.doy;
+        dow = breakParams.dow;
+        breakParams = null;
+        while (len > 0) {
+            let refOutLen = new RefParam(out_len);
+            switch (outVal[outIdx].charCodeAt(0)) {
+                case PICInterface.PIC_YY:
+                    if (pic.zeroFill() && date === 0 && date_pic_Z_edt)
+                        MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);
+                    else
+                        this.int_2_a(outVal, outIdx, 2, year, '0');
+                    outIdx += 2;
+                    len -= 2;
+                    break;
+                case PICInterface.PIC_HYYYYY:
+                    i = HebrewDate.dateheb_2_str(outVal, outIdx, len, refOutLen, 5, hyear, pic.isTrimed(), true);
+                    out_len = refOutLen.value;
+                    outIdx += i;
+                    len -= i;
+                    break;
+                case PICInterface.PIC_HL:
+                    i = HebrewDate.dateheb_i_2_h((hyear / 1000) % 10, outVal, outIdx, false, false);
+                    outIdx++;
+                    len--;
+                    break;
+                case PICInterface.PIC_HDD:
+                    i = HebrewDate.dateheb_2_str(outVal, outIdx, len, refOutLen, 2, hday, pic.isTrimed(), false);
+                    out_len = refOutLen.value;
+                    outIdx += i;
+                    len -= i;
+                    break;
+                case PICInterface.PIC_YYYY:
+                    if (pic.zeroFill() && date === 0 && date_pic_Z_edt)
+                        MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 4);
+                    else
+                        this.int_2_a(outVal, outIdx, 4, year, '0');
+                    outIdx += 4;
+                    len -= 4;
+                    break;
+                case PICInterface.PIC_MMD:
+                    if (pic.zeroFill() && date === 0 && date_pic_Z_edt)
+                        MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);
+                    else
+                        this.int_2_a(outVal, outIdx, 2, month, '0');
+                    outIdx += 2;
+                    len -= 2;
+                    break;
+                case PICInterface.PIC_MMM:
+                    if (pic.isHebrew()) {
+                        if (leap && hmonth === 6)
+                            hmonth = 14;
+                        let monthNames = HebrewDate.GetLocalMonths();
+                        p = NString.ToCharArray(monthNames[hmonth]);
+                    }
+                    else {
+                        let monthStr = Events.GetMessageString(MsgInterface.MONTHS_PTR);
+                        let monthNames = DateUtil.getLocalMonths(monthStr);
+                        p = NString.ToCharArray(monthNames[month]);
+                    }
+                    dateNameParams = new DateNameParams(outVal, outIdx, len);
+                    out_len -= this.date_i_2_nm(dateNameParams, p, pic.isTrimed());
+                    outIdx = dateNameParams.outIdx;
+                    len = dateNameParams.len;
+                    dateNameParams = null;
+                    break;
+                case PICInterface.PIC_DD:
+                    let isZero = pic.zeroFill();
+                    if (isZero && date === 0 && date_pic_Z_edt)
+                        MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);
+                    else
+                        this.int_2_a(outVal, outIdx, 2, day, '0');
+                    outIdx += 2;
+                    len -= 2;
+                    break;
+                case PICInterface.PIC_DDD:
+                    if (pic.zeroFill() && date === 0 && date_pic_Z_edt)
+                        MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 3);
+                    else
+                        this.int_2_a(outVal, outIdx, 3, doy, '0');
+                    len -= 3;
+                    outIdx += 3;
+                    break;
+                case PICInterface.PIC_DDDD:
+                    i = this.date_2_DDDD(day, outVal, outIdx, len, pic.isTrimed());
+                    outIdx += i;
+                    out_len += i - 4;
+                    len -= 4;
+                    break;
+                case PICInterface.PIC_W:
+                    if (pic.zeroFill() && date === 0 && date_pic_Z_edt)
+                        MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 1);
+                    else
+                        this.int_2_a(outVal, outIdx, 1, dow, '0');
+                    len--;
+                    outIdx++;
+                    break;
+                case PICInterface.PIC_WWW:
+                    if (pic.isHebrew()) {
+                        let dowsNames = HebrewDate.GetLocalDows();
+                        p = NString.ToCharArray(dowsNames[dow]);
+                    }
+                    else {
+                        let dayStr = Events.GetMessageString(MsgInterface.DAYS_PTR);
+                        let dayNames = DateUtil.getLocalDays(dayStr);
+                        p = NString.ToCharArray(dayNames[dow]);
+                    }
+                    dateNameParams = new DateNameParams(outVal, outIdx, len);
+                    out_len -= this.date_i_2_nm(dateNameParams, p, pic.isTrimed());
+                    outIdx = dateNameParams.outIdx;
+                    len = dateNameParams.len;
+                    dateNameParams = null;
+                    break;
+                case PICInterface.PIC_BB:
+                    p = NString.ToCharArray(UtilDateJpn.getStrDow(dow));
+                    strOut = null;
+                    dateNameParams = new DateNameParams(outVal, outIdx, len);
+                    strOut = this.date_i_2_nm_bytemode(strOut, dateNameParams, NString.FromChars(p), out_len);
+                    outVal = new Array(strOut.length);
+                    NString.CopyTo(strOut, 0, outVal, 0, strOut.length);
+                    outIdx = dateNameParams.outIdx;
+                    len = dateNameParams.len;
+                    strOut = null;
+                    dateNameParams = null;
+                    break;
+                case PICInterface.PIC_JY1:
+                case PICInterface.PIC_JY2:
+                case PICInterface.PIC_JY4:
+                    let strNum = null;
+                    if (outVal[outIdx].charCodeAt(0) === PICInterface.PIC_JY1)
+                        strNum = UtilDateJpn.getInstance().date_jpn_yr_2_a(year, doy, false);
+                    else
+                        strNum = UtilDateJpn.getInstance().date_jpn_yr_2_a(year, doy, true);
+                    strOut = null;
+                    dateNameParams = new DateNameParams(outVal, outIdx, len);
+                    strOut = this.date_i_2_nm_bytemode(strOut, dateNameParams, strNum, out_len);
+                    outVal = null;
+                    outVal = new Array(strOut.length);
+                    NString.CopyTo(strOut, 0, outVal, 0, strOut.length);
+                    outIdx = dateNameParams.outIdx;
+                    len = dateNameParams.len;
+                    strOut = null;
+                    dateNameParams = null;
+                    break;
+                case PICInterface.PIC_YJ:
+                    if (pic.zeroFill() && date === 0 && date_pic_Z_edt)
+                        MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);
+                    else
+                        this.int_2_a(outVal, outIdx, 2, UtilDateJpn.getInstance().date_jpn_year_ofs(year, doy), '0');
+                    outIdx += 2;
+                    len -= 2;
+                    break;
+                default:
+                    outIdx++;
+                    len--;
+                    break;
+            }
+        }
+        if (out_len < outVal.length)
+            MemoryUtil.char_memset(outVal, out_len, ' ', outVal.length - out_len);
+        return NString.FromChars(outVal);
+    }
+    date_break_datemode(breakParams, date, ignore_dt_fmt, compIdx) {
+        let year = breakParams.year;
+        let month = breakParams.month;
+        let day = breakParams.day;
+        let doy = breakParams.doy;
+        let dow = breakParams.dow;
+        if (date <= 0) {
+            breakParams.day = 0;
+            breakParams.doy = 0;
+            breakParams.dow = 0;
+            breakParams.year = 0;
+            breakParams.month = 0;
+        }
+        else {
+            dow = date % 7 + 1;
+            date = date - 1;
+            let cent4 = Math.floor(date / PICInterface.DAYSINFOURCENT);
+            date = date - cent4 * PICInterface.DAYSINFOURCENT;
+            let cent = Math.floor(date / PICInterface.DAYSINCENTURY);
+            if (cent > 3) {
+                cent = 3;
+            }
+            date = date - cent * PICInterface.DAYSINCENTURY;
+            let year4 = Math.floor(date / PICInterface.DAYSINFOURYEAR);
+            date = date - year4 * PICInterface.DAYSINFOURYEAR;
+            year = Math.floor(date / PICInterface.DAYSINYEAR);
+            if (year > 3) {
+                year = 3;
+            }
+            date = date - year * PICInterface.DAYSINYEAR;
+            year = cent4 * 400 + cent * 100 + year4 * 4 + year + 1;
+            let leapyear = 0;
+            if (year % 4 === 0) {
+                if (year % 100 !== 0 || year % 400 === 0) {
+                    leapyear = 1;
+                }
+            }
+            if (!ignore_dt_fmt && this._environment.GetDateMode(compIdx) === 'B') {
+                year = year + PICInterface.DATE_BUDDHIST_GAP;
+            }
+            month = (Math.floor(date / PICInterface.DAYSINMONTH) + 1);
+            day = PICInterface.date_day_tab[month];
+            if (leapyear > 0) {
+                if (month > 1) {
+                    day = day + 1;
+                }
+            }
+            if (date >= day) {
+                month = month + 1;
+            }
+            else {
+                day = PICInterface.date_day_tab[month - 1];
+                if (leapyear > 0) {
+                    if (month > 2) {
+                        day = day + 1;
+                    }
+                }
+            }
+            day = date - day + 1;
+            doy = date + 1;
+            breakParams.year = year;
+            breakParams.month = month;
+            breakParams.day = day;
+            breakParams.doy = doy;
+            breakParams.dow = dow;
+        }
+    }
+    int_2_a(str, strPos, len, n, lead) {
+        let neg = n < 0;
+        if (len <= 0)
+            return;
+        n = Math.abs(n);
+        let pos = len;
+        do {
+            str[strPos + (pos = pos - 1)] = String.fromCharCode(48 + n % 10);
+            n = Math.floor(n / 10);
+        } while (pos > 0 && n > 0);
+        if (neg && pos > 0) {
+            str[strPos + (pos = pos - 1)] = '-';
+        }
+        return this.lib_a_fill(str, strPos, len, pos, lead.charCodeAt(0));
+    }
+    lib_a_fill(str, strPos, len, pos, lead) {
+        if (lead === 0) {
+            len = len - pos;
+            if (len > 0 && pos > 0) {
+                MemoryUtil.char_memcpy(str, strPos, str, pos, len);
+                MemoryUtil.char_memset(str, strPos + len, ' ', pos);
+            }
+        }
+        else {
+            if (pos > 0) {
+                MemoryUtil.char_memset(str, strPos, String.fromCharCode(lead), pos);
+            }
+        }
+        return len;
+    }
+    date_i_2_nm(dateNameParams, nm, trim) {
+        let n = this.date_msk_cnt(dateNameParams.outVal, dateNameParams.outIdx, dateNameParams.len);
+        let l;
+        if (trim) {
+            l = MemoryUtil.mem_trim(nm, 0, n);
+        }
+        else {
+            l = n;
+        }
+        l = Math.min(l, dateNameParams.len);
+        MemoryUtil.char_memcpy(dateNameParams.outVal, dateNameParams.outIdx, nm, 0, l);
+        dateNameParams.outIdx = dateNameParams.outIdx + l;
+        dateNameParams.len = dateNameParams.len - n;
+        n = n - l;
+        if (n > 0) {
+            MemoryUtil.char_memcpy(dateNameParams.outVal, dateNameParams.outIdx, dateNameParams.outVal, dateNameParams.outIdx + n, dateNameParams.len);
+        }
+        return n;
+    }
+    date_i_2_nm_bytemode(strOut, dateNameParams, strNm, intOutLen) {
+        let intMskCnt = this.date_msk_cnt(dateNameParams.outVal, dateNameParams.outIdx, dateNameParams.len);
+        let strWork = NString.FromChars(dateNameParams.outVal);
+        strWork = strWork.substr(0, dateNameParams.outIdx);
+        let intOfs = UtilStrByteMode.lenB(strWork);
+        strNm = UtilStrByteMode.leftB(strNm, intMskCnt);
+        strOut = UtilStrByteMode.repB(NString.FromChars(dateNameParams.outVal), strNm, intOfs + 1, intMskCnt);
+        dateNameParams.outIdx = dateNameParams.outIdx + strNm.length;
+        dateNameParams.len = dateNameParams.len - intMskCnt;
+        intOutLen = intOutLen - intMskCnt;
+        return strOut;
+    }
+    date_msk_cnt(msk, mskPos, len) {
+        let c = msk[mskPos++];
+        let i = 1;
+        while (i < len) {
+            if (msk[mskPos] !== c) {
+                break;
+            }
+            mskPos = mskPos + 1;
+            i = i + 1;
+        }
+        return i;
+    }
+    date_2_DDDD(day, outVal, outIdx, len, trim) {
+        let ret = 4;
+        let ext;
+        if (day > 9) {
+            this.int_2_a(outVal, outIdx, 2, day, 0..toString());
+            outIdx += 2;
+        }
+        else {
+            if (trim) {
+                MemoryUtil.char_memcpy(outVal, outIdx, outVal, outIdx + 1, len - 1);
+                ret--;
+            }
+            else {
+                outVal[outIdx++] = ' ';
+            }
+            this.int_2_a(outVal, outIdx, 1, day, 0..toString());
+            outIdx++;
+        }
+        switch (day) {
+            case 1:
+            case 21:
+            case 31:
+                ext = NString.ToCharArray("st");
+                break;
+            case 2:
+            case 22:
+                ext = NString.ToCharArray("nd");
+                break;
+            case 3:
+            case 23:
+                ext = NString.ToCharArray("rd");
+                break;
+            default:
+                ext = NString.ToCharArray("th");
+                break;
+        }
+        outVal[outIdx++] = ext[0];
+        outVal[outIdx] = ext[1];
+        return (ret);
+    }
+    fromMgTimeToNativeTime(dataStr, pic) {
+        let time = new NUM_TYPE(dataStr).NUM_2_ULONG();
+        let breakParams = new TimeBreakParams();
+        DisplayConvertor.time_break(breakParams, time);
+        let nativeDt = new Date(0);
+        let maskStr = pic.getMask();
+        let outVal = NString.ToCharArray(maskStr);
+        let len = pic.getMaskSize();
+        let outIdx = 0;
+        while (len > 0) {
+            switch (outVal[outIdx].charCodeAt(0)) {
+                case (PICInterface.PIC_HH):
+                    nativeDt.setHours(breakParams.hour);
+                    outIdx += 2;
+                    len -= 2;
+                    break;
+                case (PICInterface.PIC_MMT):
+                    nativeDt.setMinutes(breakParams.minute);
+                    outIdx += 2;
+                    len -= 2;
+                    break;
+                case (PICInterface.PIC_SS):
+                    nativeDt.setSeconds(breakParams.second);
+                    outIdx += 2;
+                    len -= 2;
+                    break;
+                default:
+                    outIdx++;
+                    len--;
+            }
+        }
+        return nativeDt;
+    }
+    time_2_a_pic(AsciiStr, AsciiL, time, pic, time_pic_Z_edt, milliSeconds) {
+        let hour = 0;
+        let minute = 0;
+        let second = 0;
+        let millisec = 0;
+        let Ascii = NString.ToCharArray(AsciiStr);
+        let breakParams = new TimeBreakParams(hour, minute, second);
+        let timeSec;
+        if (milliSeconds) {
+            timeSec = Math.floor(time / 1000);
+            millisec = time - timeSec * 1000;
+        }
+        else {
+            timeSec = time;
+        }
+        DisplayConvertor.time_break(breakParams, timeSec);
+        hour = breakParams.hour;
+        minute = breakParams.minute;
+        second = breakParams.second;
+        let result;
+        if (pic.getMaskSize() > AsciiL) {
+            MemoryUtil.char_memset(Ascii, 0, '*', AsciiL);
+            result = NString.FromChars(Ascii);
+        }
+        else {
+            if (pic.zeroFill()) {
+                if (timeSec === 0 && (!milliSeconds || millisec === 0)) {
+                    if (time_pic_Z_edt) {
+                        for (let intx = 0; intx < pic.getMaskSize(); intx = intx + 1) {
+                            if (Ascii[intx] <= '\u001f') {
+                                Ascii[intx] = pic.getZeroPad();
+                            }
+                        }
+                        result = NString.FromChars(Ascii);
+                        return result;
+                    }
+                    MemoryUtil.char_memset(Ascii, 0, pic.getZeroPad(), pic.getMaskSize());
+                    result = NString.FromChars(Ascii);
+                    return result;
+                }
+            }
+            let I = 0;
+            let am = 0;
+            let len = pic.getMaskSize();
+            let HourI = -1;
+            while (I < len) {
+                switch (Ascii[I].charCodeAt(0)) {
+                    case (PICInterface.PIC_HH):
+                        HourI = I;
+                        I += 2;
+                        break;
+                    case (PICInterface.PIC_MMT):
+                        this.int_2_a(Ascii, I, 2, minute, '0');
+                        I += 2;
+                        break;
+                    case (PICInterface.PIC_SS):
+                        this.int_2_a(Ascii, I, 2, second, '0');
+                        I += 2;
+                        break;
+                    case (PICInterface.PIC_MS):
+                        this.int_2_a(Ascii, I, 3, millisec, '0');
+                        I += 3;
+                        break;
+                    case (PICInterface.PIC_PM):
+                        am = 1;
+                        let tmpHour = hour % 24;
+                        if (tmpHour < 12 || tmpHour === 0)
+                            MemoryUtil.char_memcpy(Ascii, I, NString.ToCharArray("am"), 0, 2);
+                        else
+                            MemoryUtil.char_memcpy(Ascii, I, NString.ToCharArray("pm"), 0, 2);
+                        I += 2;
+                        break;
+                    default:
+                        I++;
+                        break;
+                }
+            }
+            if (HourI >= 0) {
+                if (am > 0) {
+                    hour = hour % 24;
+                    if (hour === 0) {
+                        hour = 12;
+                    }
+                    else {
+                        hour = hour % 12;
+                        if (hour === 0) {
+                            hour = 12;
+                        }
+                    }
+                }
+                this.int_2_a(Ascii, HourI, 2, hour, (am !== 0 && hour < 10) ? ' ' : '0');
+            }
+            result = NString.FromChars(Ascii);
+        }
+        return result;
+    }
+    static time_break(breakParams, time) {
+        if (time <= 0) {
+            breakParams.second = 0;
+            breakParams.minute = 0;
+            breakParams.hour = 0;
+        }
+        else {
+            breakParams.hour = Math.floor(time / 3600);
+            time = time - breakParams.hour * 3600;
+            breakParams.minute = Math.floor(time / 60);
+            breakParams.second = time - breakParams.minute * 60;
+        }
+    }
+    fromMgLogicalToNativeLogical(dataStr) {
+        let nativeVal;
+        nativeVal = (dataStr.charAt(0) === '1') ? true : false;
+        return nativeVal;
+    }
+    fromNativeLogicalToMgLogical(dispVal) {
+        let mgVal;
+        mgVal = (dispVal === true) ? "1" : "0";
+        return mgVal;
+    }
+    win_rng_bool(rng) {
+        if (rng === null || rng.length === 0) {
+            rng = "True, False";
+        }
+        return rng;
+    }
+    toNum(dispValue, pic, compIdx) {
+        let mgNum = new NUM_TYPE(dispValue, pic, compIdx);
+        return mgNum.toXMLrecord();
+    }
+    a_2_date_pic_datemode(str, str_len, pic, mask, compIdx) {
+        let pos = 0;
+        let year_in_pic = false;
+        let month_in_pic = false;
+        let day_in_pic = false;
+        let inp = false;
+        let bYearIsZero = false;
+        let era_year = 0;
+        let intRef = new IntRef(0);
+        let intPicIdxOfs = 0;
+        let millenium = 0;
+        let dateParams;
+        let len = Math.min(str.length, pic.getMaskSize());
+        if (str.length < mask.length)
+            str.length = mask.length;
+        let year = 0;
+        let month = 1;
+        let day = 1;
+        let doy = 1;
+        let usedoy = false;
+        let i;
+        for (i = 0; i < str_len; i = i + 1) {
+            if (str[i] !== '0' && str[i] !== ' ') {
+                break;
+            }
+        }
+        if (i === str_len)
+            return 0;
+        while (pos < str_len && pos + intPicIdxOfs < len) {
+            switch (mask[pos + intPicIdxOfs].charCodeAt(0)) {
+                case PICInterface.PIC_YY:
+                    year_in_pic = true;
+                    inp = true;
+                    year = this.date_a_2_i(str, 2, pos);
+                    pos += 2;
+                    if (year === 0)
+                        bYearIsZero = true;
+                    let century_year = this._environment.GetCentury(compIdx) % 100;
+                    if (year < century_year)
+                        year += 100;
+                    year += this._environment.GetCentury(compIdx) - century_year;
+                    if (this._environment.GetDateMode(compIdx) === 'B')
+                        year -= PICInterface.DATE_BUDDHIST_GAP;
+                    break;
+                case (PICInterface.PIC_YYYY):
+                    year_in_pic = true;
+                    inp = true;
+                    let YearDigitsNo;
+                    if (UtilStrByteMode.isLocaleDefLangJPN()) {
+                        for (YearDigitsNo = 0; YearDigitsNo < 4 && pos + YearDigitsNo < str.length && UtilStrByteMode.isDigit(str[pos + YearDigitsNo]); YearDigitsNo++) {
+                        }
+                        i = YearDigitsNo;
+                    }
+                    else {
+                        for (i = 0; pos + i < str.length && str[pos + i] !== this.DATECHAR.toString() && i < 4; i++) {
+                        }
+                        for (YearDigitsNo = 0; pos + YearDigitsNo < str.length && UtilStrByteMode.isDigit(str[pos + YearDigitsNo]) &&
+                            YearDigitsNo < 4; YearDigitsNo++) {
+                        }
+                    }
+                    if (UtilStrByteMode.isLocaleDefLangJPN()) {
+                        if (i < 4 && str.length < mask.length)
+                            this.move_date(str, pos, 4 - i, str.length);
+                    }
+                    else {
+                        if (i < 4 && len < mask.length) {
+                            this.move_date(str, pos, 4 - i, len);
+                            len = len + 4 - i;
+                        }
+                    }
+                    year = this.date_a_2_i(str, 4, pos);
+                    pos += 4;
+                    if (year === 0)
+                        bYearIsZero = true;
+                    if (YearDigitsNo <= 2) {
+                        century_year = this._environment.GetCentury(compIdx) % 100;
+                        if (year < century_year)
+                            year += 100;
+                        year += this._environment.GetCentury(compIdx) - century_year;
+                    }
+                    if (this._environment.GetDateMode(compIdx) === 'B')
+                        year -= PICInterface.DATE_BUDDHIST_GAP;
+                    break;
+                case PICInterface.PIC_HYYYYY:
+                    inp = true;
+                    let quotes = 0;
+                    if (len > pos + 5 && mask[pos + 5].charCodeAt(0) === (PICInterface.PIC_HYYYYY))
+                        quotes = 1;
+                    year = HebrewDate.dateheb_h_2_i(str, 5 + quotes, pos);
+                    pos += 5 + quotes;
+                    if (year === 0)
+                        bYearIsZero = true;
+                    break;
+                case PICInterface.PIC_HL:
+                    intPicIdxOfs = HebrewDate.dateheb_h_2_i(str, 1, pos);
+                    pos++;
+                    break;
+                case PICInterface.PIC_HDD:
+                    inp = true;
+                    quotes = 0;
+                    if (len > pos + 2 && mask[pos + 2].charCodeAt(0) === PICInterface.PIC_HDD)
+                        quotes = 1;
+                    day = HebrewDate.dateheb_h_2_i(str, 2 + quotes, pos);
+                    pos += 2 + quotes;
+                    break;
+                case PICInterface.PIC_MMD:
+                    inp = true;
+                    month_in_pic = true;
+                    if (UtilStrByteMode.isLocaleDefLangJPN()) {
+                        if ((str.length === pos + 1 || str[pos + 1].charCodeAt(0) === this.DATECHAR || !UtilStrByteMode.isDigit(str[pos + 1])) && str.length < mask.length)
+                            this.move_date(str, pos, 1, str.length);
+                    }
+                    else {
+                        if (str[pos + 1].charCodeAt(0) === this.DATECHAR && len < mask.length) {
+                            this.move_date(str, pos, 1, len);
+                            len += 1;
+                        }
+                    }
+                    month = this.date_a_2_i(str, 2, pos);
+                    pos += 2;
+                    break;
+                case PICInterface.PIC_MMM:
+                    inp = true;
+                    month_in_pic = true;
+                    intRef.val = pos;
+                    month = this.date_MMM_2_m(str, mask, intRef, len, pic.isHebrew());
+                    pos = intRef.val;
+                    if (pic.isHebrew() && month === 14)
+                        month = 6;
+                    break;
+                case (PICInterface.PIC_DD):
+                    inp = true;
+                    day_in_pic = true;
+                    if (UtilStrByteMode.isLocaleDefLangJPN()) {
+                        if ((str.length === pos + 1 || str[pos + 1].charCodeAt(0) === this.DATECHAR || !UtilStrByteMode.isDigit(str[pos + 1])) && str.length < mask.length)
+                            this.move_date(str, pos, 1, str.length);
+                    }
+                    else {
+                        if (str[pos + 1].charCodeAt(0) === this.DATECHAR && len < mask.length) {
+                            this.move_date(str, pos, 1, len);
+                            len += 1;
+                        }
+                    }
+                    day = this.date_a_2_i(str, 2, pos);
+                    pos += 2;
+                    break;
+                case (PICInterface.PIC_DDD):
+                    inp = true;
+                    usedoy = true;
+                    day_in_pic = true;
+                    doy = this.date_a_2_i(str, 3, pos);
+                    pos += 3;
+                    break;
+                case (PICInterface.PIC_DDDD):
+                    inp = true;
+                    day_in_pic = true;
+                    day = this.date_a_2_i(str, 2, pos);
+                    pos += 2 + 2;
+                    break;
+                case (PICInterface.PIC_YJ):
+                    year_in_pic = true;
+                    inp = true;
+                    if (UtilStrByteMode.isLocaleDefLangJPN()) {
+                        if ((str.length === pos + 1 || str[pos + 1].charCodeAt(0) === this.DATECHAR || !UtilStrByteMode.isDigit(str[pos + 1])) && str.length < mask.length)
+                            this.move_date(str, pos, 1, str.length);
+                    }
+                    year = this.date_a_2_i(str, 2, pos);
+                    pos += 2;
+                    let str1 = NString.FromChars(str);
+                    era_year = UtilDateJpn.getInstance().getStartYearOfEra(str1, pic.getMask());
+                    if (era_year === 0)
+                        return 0;
+                    year += era_year - 1;
+                    if (year === 0)
+                        bYearIsZero = true;
+                    break;
+                default:
+                    if (UtilStrByteMode.isLocaleDefLangDBCS()) {
+                        if (UtilStrByteMode.isHalfWidth(str[pos]) === false &&
+                            UtilStrByteMode.isHalfWidth(mask[pos + intPicIdxOfs]))
+                            intPicIdxOfs++;
+                    }
+                    pos += 1;
+                    break;
+            }
+        }
+        if (bYearIsZero) {
+            if (!month_in_pic)
+                month = 0;
+            if (!day_in_pic && month === 0)
+                day = 0;
+        }
+        if (day === 0 && month === 0 && (bYearIsZero || year === 0))
+            return (0);
+        if (!inp)
+            return (0);
+        if (pic.isHebrew()) {
+            if (year > 0) {
+                if (millenium === 0)
+                    millenium = 5;
+                year += millenium * 1000;
+            }
+            return (HebrewDate.dateheb_2_d(year, month, day));
+        }
+        if ((year === 0) && !year_in_pic) {
+            dateParams = this.date_sys();
+            year = dateParams.year;
+        }
+        return (this.date_4_calender(year, month, day, doy, usedoy));
+    }
+    date_a_2_i(s, len, pos) {
+        if (arguments.length === 3 && (s === null || s instanceof Array) && (len === null || len.constructor === Number) && (pos === null || pos.constructor === Number)) {
+            return this.date_a_2_i_0(s, len, pos);
+        }
+        return this.date_a_2_i_1(s, len, pos);
+    }
+    date_a_2_i_0(s, len, pos) {
+        let array = new Array(len);
+        let mgNum = new NUM_TYPE();
+        for (let i = 0; i < len; i = i + 1) {
+            array[i] = s[pos + i];
+        }
+        return mgNum.a_2_long(NString.FromChars(array));
+    }
+    move_date(str, pos, moveby, len) {
+        if (arguments.length === 4 && (str === null || str instanceof Array) && (pos === null || pos.constructor === Number) && (moveby === null || moveby.constructor === Number) && (len === null || len.constructor === Number)) {
+            this.move_date_0(str, pos, moveby, len);
+            return;
+        }
+        this.move_date_1(str, pos, moveby, len);
+    }
+    move_date_0(str, pos, moveby, len) {
+        MemoryUtil.char_memmove(str, pos + moveby, str, pos, len - (pos + moveby) + 1);
+        MemoryUtil.char_memset(str, pos, '0', moveby);
+    }
+    date_MMM_2_m(str, mask, pos, len, isHebrew) {
+        let l;
+        if (UtilStrByteMode.isLocaleDefLangJPN()) {
+            let maskPos = UtilStrByteMode.convPos(NString.FromChars(str), NString.FromChars(mask), pos.val, false);
+            l = this.date_msk_cnt(mask, maskPos, (len - maskPos));
+        }
+        else {
+            l = this.date_msk_cnt(mask, pos.val, (len - pos.val));
+        }
+        let strPos = pos.val;
+        pos.val = pos.val + l;
+        len = MemoryUtil.mem_trim(str, strPos, l);
+        if (len === 0) {
+            return 0;
+        }
+        else {
+            let strB = NString.FromChars(str, strPos, len);
+            let monthNames;
+            if (isHebrew) {
+                monthNames = HebrewDate.GetLocalMonths();
+            }
+            else {
+                let months = Events.GetMessageString(MsgInterface.MONTHS_PTR);
+                monthNames = DateUtil.getLocalMonths(months);
+            }
+            for (let i = 1; i < monthNames.length; i = i + 1) {
+                if (NString.Compare(monthNames[i].substr(0, len), strB, true) === 0)
+                    return i;
+            }
+        }
+        return 0;
+    }
+    date_sys() {
+        let date = new DateBreakParams();
+        let CurrDate = DateTime.Now;
+        date.year = CurrDate.Year;
+        date.month = CurrDate.Month;
+        date.day = CurrDate.Day;
+        return date;
+    }
+    date_magic(utcDate) {
+        let dateTime;
+        if (utcDate) {
+            dateTime = DateTime.UtcNow;
+        }
+        else {
+            dateTime = DateTime.Now;
+        }
+        let year = dateTime.Year;
+        let month = dateTime.Month;
+        let day = dateTime.Day;
+        return this.date_4_calender(year, month, day, 1, false);
+    }
+    time_magic(utcTime) {
+        return DateTime.GetTotalSecondsFromMidnight(utcTime, new Date());
+    }
+    mtime_magic(utcTime) {
+        return DateTime.GetTotalMilliSecondsFromMidnight(utcTime, new Date());
+    }
+    date_4_calender(year, month, day, doy, usedoy) {
+        let LeapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+        if (usedoy) {
+            if (doy === 0) {
+                return 0;
+            }
+            if (doy > 366 || (!LeapYear && doy > 365)) {
+                return (1000000000);
+            }
+        }
+        else {
+            if (day === 0 && month === 0 && year === 0) {
+                return 0;
+            }
+            if (day === 0 || month === 0 || year === 0 || month > 12) {
+                return 1000000000;
+            }
+        }
+        year = year - 1;
+        let num = Math.floor(year / 400);
+        year = year - num * 400;
+        let num2 = Math.floor(year / 100);
+        year = year - num2 * 100;
+        let num3 = Math.floor(year / 4);
+        year = year - num3 * 4;
+        if (!usedoy) {
+            let num4 = PICInterface.date_day_tab[month - 1];
+            let num5 = PICInterface.date_day_tab[month];
+            if (LeapYear) {
+                if (month > 1) {
+                    num5 = num5 + 1;
+                    if (month > 2) {
+                        num4 = num4 + 1;
+                    }
+                }
+            }
+            if (day > num5 - num4) {
+                return 1000000000;
+            }
+            doy = num4 + day;
+        }
+        return num * 146097 + num2 * 36524 + num3 * 1461 + year * 365 + doy;
+    }
+    fromNativeTimeToMgTime(dispValue) {
+        let mgNum = new NUM_TYPE();
+        let numVal = this.fromNativeTimeToMgTimeNumber(dispValue);
+        mgNum.NUM_4_LONG(numVal);
+        return mgNum.toXMLrecord();
+    }
+    fromNativeTimeToMgTimeNumber(dispValue) {
+        let numVal = this.time_2_int(dispValue.getHours(), dispValue.getMinutes(), dispValue.getSeconds());
+        return numVal;
+    }
+    a_2_time(Ascii, picOrAsciiL, milliSecondsOrMask, milliSeconds) {
+        if (arguments.length === 3)
+            return this.a_2_time_0(Ascii, picOrAsciiL, milliSecondsOrMask);
+        return this.a_2_time_1(Ascii, picOrAsciiL, milliSecondsOrMask, milliSeconds);
+    }
+    a_2_time_0(Ascii, pic, milliSeconds) {
+        return this.a_2_time(Ascii, Ascii.length, NString.ToCharArray(pic.getMask()), milliSeconds);
+    }
+    a_2_time_1(Ascii, AsciiL, mask, milliSeconds) {
+        let mgNum = new NUM_TYPE();
+        let I = 0;
+        let len = mask.length;
+        if (len > AsciiL) {
+            len = AsciiL;
+        }
+        let ampm = 0;
+        let hour = 0;
+        let minute = 0;
+        let second = 0;
+        let millisecond = 0;
+        while (I < len) {
+            let maskLength;
+            let maxMaskLen;
+            switch (mask[I].charCodeAt(0)) {
+                case (PICInterface.PIC_HH):
+                case (PICInterface.PIC_MMT):
+                case (PICInterface.PIC_SS):
+                case (PICInterface.PIC_PM):
+                    maxMaskLen = 2;
+                    break;
+                case (PICInterface.PIC_MS):
+                    maxMaskLen = 3;
+                    break;
+                default:
+                    maxMaskLen = 1;
+                    break;
+            }
+            maskLength = Math.min(maxMaskLen, len - I);
+            switch (mask[I].charCodeAt(0)) {
+                case (PICInterface.PIC_HH):
+                    {
+                        hour = mgNum.a_2_long(Ascii.substr(I, maskLength));
+                    }
+                    break;
+                case (PICInterface.PIC_MMT):
+                    {
+                        minute = mgNum.a_2_long(Ascii.substr(I, maskLength));
+                    }
+                    break;
+                case (PICInterface.PIC_SS):
+                    {
+                        second = mgNum.a_2_long(Ascii.substr(I, maskLength));
+                    }
+                    break;
+                case (PICInterface.PIC_MS):
+                    {
+                        millisecond = mgNum.a_2_long(Ascii.substr(I, maskLength));
+                    }
+                    break;
+                case (PICInterface.PIC_PM):
+                    ampm = 0;
+                    let c0 = Ascii[I];
+                    let c1;
+                    c0 = c0.toUpperCase();
+                    if (I + 1 < len) {
+                        c1 = Ascii[I + 1];
+                        c1 = c1.toUpperCase();
+                        if (c1 === 'M') {
+                            if (c0 === 'A')
+                                ampm = -1;
+                            if (c0 === 'P')
+                                ampm = 1;
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+            I += maskLength;
+        }
+        if (second > 59 || minute > 59)
+            return (0);
+        if (ampm !== 0)
+            if (ampm === -1) {
+                if (hour === 12)
+                    hour = 0;
+            }
+            else if (hour < 12)
+                hour += 12;
+        if (milliSeconds)
+            return this.time_2_int(hour, minute, second) * 1000 + millisecond;
+        else
+            return this.time_2_int(hour, minute, second);
+    }
+    time_2_int(hour, minute, second) {
+        return hour * 3600 + minute * 60 + second;
+    }
+    static toBoolean(boolStr) {
+        return boolStr !== null && boolStr === "1";
+    }
+    a_2_date(str, Format, compIdx) {
+        return this.a_2_date_datemode(str, Format, compIdx);
+    }
+    a_2_date_pic(str, pic, mask, compIdx) {
+        if (str === null) {
+            str = "";
+        }
+        return this.a_2_date_pic_datemode(NString.ToCharArray(str), str.length, pic, NString.ToCharArray(mask), compIdx);
+    }
+    to_a(outVal, out_len, date, Format, compIdx) {
+        return this.to_a_datemode(outVal, out_len, date, Format, false, compIdx);
+    }
+    a_2_date_datemode(str, Format, compIdx) {
+        let pIC = new PIC(Format, StorageAttribute.DATE, compIdx);
+        if (str === null) {
+            str = "";
+        }
+        return this.a_2_date_pic_datemode(NString.ToCharArray(str), str.length, pIC, NString.ToCharArray(pIC.getMask()), compIdx);
+    }
+    to_a_datemode(outVal, out_len, date, Format, ignore_dt_fmt, compIdx) {
+        let pic = new PIC(Format, StorageAttribute.DATE, compIdx);
+        if (outVal === null) {
+            outVal = pic.getMask();
+        }
+        return this.to_a_pic_datemode(outVal, out_len, date, pic, true, ignore_dt_fmt, compIdx);
+    }
+    date_a_2_i_1(s, len, pos) {
+        let mgNum = new NUM_TYPE();
+        let str;
+        str = s.substr(pos, len);
+        return mgNum.a_2_long(str);
+    }
+    move_date_1(str, pos, moveby, len) {
+        str = StrUtil.memmove(str, pos + moveby, str, pos, len - pos);
+        str = StrUtil.memset(str, pos, '0', moveby);
+        return str;
+    }
+    time_2_a(Ascii, AsciiL, time, Format, compIdx, milliSeconds) {
+        if (StrUtil.rtrim(Format).length === 0) {
+            Format = "HH:MM:SS";
+        }
+        let pic = new PIC(Format, StorageAttribute.TIME, compIdx);
+        if (Ascii === null) {
+            Ascii = pic.getMask();
+        }
+        return this.time_2_a_pic(Ascii, AsciiL, time, pic, false, milliSeconds);
+    }
+    toLogical(dispValue, pic, rangeStr) {
+        dispValue = dispValue.trim();
+        if (dispValue === null || dispValue.length === 0) {
+            dispValue = "False";
+        }
+        return this.disp_2_logical(dispValue, pic.getMask(), rangeStr);
+    }
+    disp_2_logical(dispValue, mask, rangeStr) {
+        let strippedValue = new StringBuilder(dispValue.length);
+        rangeStr = this.win_rng_bool(rangeStr);
+        rangeStr = StrUtil.makePrintableTokens(rangeStr, SEQ_2_HTML);
+        let i = rangeStr.indexOf(',');
+        let trueStr = rangeStr.substr(0, i);
+        trueStr = StrUtil.makePrintableTokens(trueStr, HTML_2_STR);
+        i = 0;
+        for (i = 0; i < dispValue.length && i < mask.length; i++) {
+            if (mask.charCodeAt(i) === PICInterface.PIC_X) {
+                strippedValue.Append(dispValue.charAt(i));
+            }
+        }
+        let val = strippedValue.ToString();
+        if (trueStr.length < val.length) {
+            val = val.substr(0, trueStr.length);
+        }
+        else {
+            if (val.length < trueStr.length) {
+                trueStr = trueStr.substr(0, val.length);
+            }
+        }
+        return (val.toUpperCase() === trueStr.toUpperCase()) ? "1" : "0";
+    }
+    toAlpha(dispValue, pic) {
+        let picture = pic.getMask();
+        let buffer = new StringBuilder(pic.getMaskSize());
+        let IsAlphaDBCS = UtilStrByteMode.isLocaleDefLangDBCS() && pic.isAttrAlpha();
+        let currPicture;
+        let i = currPicture = 0;
+        for (currPicture = i = 0; i < dispValue.length && currPicture < picture.length; i++, currPicture++) {
+            if (DisplayConvertor.isAlphaPositionalDirective(picture.charAt(currPicture))) {
+                buffer.Append(dispValue.charAt(i));
+                if (IsAlphaDBCS) {
+                    let strDspValOneChar = dispValue.substr(i, 1);
+                    if (UtilStrByteMode.lenB(strDspValOneChar) === 2) {
+                        currPicture = currPicture + 1;
+                    }
+                }
+            }
+        }
+        return buffer.ToString();
+    }
+    static isAlphaPositionalDirective(toCheck) {
+        let ascii = toCheck.charCodeAt(0);
+        return (ascii === PICInterface.PIC_X || ascii === PICInterface.PIC_U || ascii === PICInterface.PIC_L ||
+            ascii === PICInterface.PIC_N || ascii === PICInterface.PIC_J || ascii === PICInterface.PIC_G || ascii === PICInterface.PIC_S || ascii === PICInterface.PIC_T);
+    }
+    fillAlphaByRange(ContinuousRangeValues, discreteRangeValues, newValue) {
+        let tmpBuffer = this.fillAlphaByDiscreteRangeValues(discreteRangeValues, newValue);
+        if (tmpBuffer !== null) {
+            return tmpBuffer;
+        }
+        else {
+            tmpBuffer = this.fillAlphaByContinuousRangeValues(ContinuousRangeValues, newValue);
+            if (tmpBuffer !== null) {
+                return tmpBuffer;
+            }
+            else {
+                if (discreteRangeValues !== null) {
+                    tmpBuffer = this.completeAlphaByRange(discreteRangeValues, newValue);
+                    if (tmpBuffer !== null) {
+                        return tmpBuffer;
+                    }
+                }
+            }
+        }
+        return newValue;
+    }
+    fillAlphaByDiscreteRangeValues(discreteRangeValues, newValue) {
+        if (discreteRangeValues !== null) {
+            for (let i = 0; i < discreteRangeValues.length; i = i + 1) {
+                let discreteValue = discreteRangeValues.get_Item(i);
+                let truncatedValue = discreteValue.substr(0, Math.min(newValue.length, discreteValue.length));
+                if (newValue.toUpperCase() === truncatedValue.toUpperCase()) {
+                    return discreteValue;
+                }
+            }
+        }
+        return null;
+    }
+    fillAlphaByContinuousRangeValues(ContinuousRangeValues, newValue) {
+        newValue = StrUtil.rtrim(newValue);
+        if (ContinuousRangeValues !== null) {
+            for (let i = 0; i < ContinuousRangeValues.length; i = i + 1) {
+                let from = ContinuousRangeValues.get_Item(i);
+                let to = ContinuousRangeValues.get_Item(i = i + 1);
+                if (NString.CompareOrdinal(newValue, from) >= 0 && NString.CompareOrdinal(newValue, to) <= 0) {
+                    return newValue;
+                }
+            }
+        }
+        return null;
+    }
+    completeAlphaByRange(discreteRangeValues, newValue) {
+        let maxCoincide = new Array(2);
+        for (let _ai = 0; _ai < maxCoincide.length; ++_ai)
+            maxCoincide[_ai] = 0;
+        let bestItem = new Array(2);
+        for (let _ai = 0; _ai < bestItem.length; ++_ai)
+            bestItem[_ai] = null;
+        let CHECK_CASE = 0;
+        let IGNORE_CASE = 1;
+        let caseLetters = CHECK_CASE;
+        while (caseLetters === CHECK_CASE || caseLetters === IGNORE_CASE) {
+            let lowerValue;
+            if (caseLetters === CHECK_CASE) {
+                lowerValue = newValue;
+            }
+            else {
+                lowerValue = newValue.toLowerCase();
+            }
+            lowerValue = StrUtil.rtrim(lowerValue);
+            for (let i = 0; i < discreteRangeValues.length; i = i + 1) {
+                let wrongLetter = false;
+                let currCoincide = 0;
+                let rangeItem;
+                if (caseLetters === CHECK_CASE) {
+                    rangeItem = discreteRangeValues.get_Item(i);
+                }
+                else {
+                    rangeItem = discreteRangeValues.get_Item(i).toLowerCase();
+                }
+                let lowLength = lowerValue.length;
+                let rangeLength = rangeItem.length;
+                if (lowLength < rangeLength) {
+                    for (let j = 0; j < lowLength; j = j + 1) {
+                        if (!(lowerValue.charAt(j) === rangeItem.charAt(j))) {
+                            wrongLetter = true;
+                            break;
+                        }
+                        currCoincide = currCoincide + 1;
+                    }
+                }
+                else {
+                    wrongLetter = true;
+                }
+                if (currCoincide > maxCoincide[caseLetters] && !wrongLetter) {
+                    bestItem[caseLetters] = discreteRangeValues.get_Item(i);
+                    maxCoincide[caseLetters] = currCoincide;
+                }
+            }
+            caseLetters = caseLetters + 1;
+        }
+        if (bestItem[CHECK_CASE] !== null)
+            return bestItem[CHECK_CASE];
+        else {
+            if (bestItem[IGNORE_CASE] !== null)
+                return bestItem[IGNORE_CASE];
+        }
+        return null;
+    }
+    setDateChar(dateChar) {
+        this.DATECHAR = dateChar;
+    }
+    getDateChar() {
+        return this.DATECHAR;
+    }
+    static StringValueToMgValue(value, storageAttribute, filler, length) {
+        switch (storageAttribute) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE: {
+                let newVal = value;
+                newVal = NString.PadRight(newVal, length, filler);
+                return newVal;
+            }
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                return new NUM_TYPE(value);
+            default:
+                return value;
+        }
+    }
+}
+export class TimeBreakParams {
+    hour = 0;
+    minute = 0;
+    second = 0;
+    constructor(hour_, minute_, second_) {
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        this.constructor_1(hour_, minute_, second_);
+    }
+    constructor_0() {
+    }
+    constructor_1(hour_, minute_, second_) {
+        this.hour = hour_;
+        this.minute = minute_;
+        this.second = second_;
+    }
+}
+class IntRef {
+    val = 0;
+    constructor(val_) {
+        this.val = val_;
+    }
+}
+class DateNameParams {
+    outVal = null;
+    len = 0;
+    outIdx = 0;
+    constructor(out_, outIdx_, len_) {
+        this.outVal = out_;
+        this.outIdx = outIdx_;
+        this.len = len_;
+    }
+}
+export class DateBreakParams {
+    day = 0;
+    dow = 0;
+    doy = 0;
+    month = 0;
+    year = 0;
+    constructor(year_, month_, day_, doy_, dow_) {
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        this.constructor_1(year_, month_, day_, doy_, dow_);
+    }
+    constructor_0() {
+    }
+    constructor_1(year_, month_, day_, doy_, dow_) {
+        this.year = year_;
+        this.month = month_;
+        this.day = day_;
+        this.doy = doy_;
+        this.dow = dow_;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DisplayConvertor.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/gui/DisplayConvertor.ts"],"names":[],"mappings":"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","sourcesContent":["import {IEnvironment} from '../../env/IEnvironment';\r\nimport {PIC} from './PIC';\r\nimport {DateTime, List, NString, RefParam, StringBuilder} from '@magic-xpa/mscorelib';\r\nimport {\r\n  DateUtil,\r\n  HTML_2_STR,\r\n  MsgInterface,\r\n  PICInterface,\r\n  SEQ_2_HTML,\r\n  StorageAttribute,\r\n  StrUtil,\r\n  UtilDateJpn,\r\n  UtilStrByteMode\r\n} from '@magic-xpa/utils';\r\nimport {BlobType} from '../data/BlobType';\r\nimport {ValidationDetailsBase} from './ValidationDetailsBase';\r\nimport {NUM_TYPE} from '../data/NUM_TYPE';\r\nimport {HebrewDate} from './HebrewDate';\r\nimport {Events} from '../../Events';\r\nimport {GuiEnvironment} from '../../GuiEnvironment';\r\nimport {MemoryUtil} from '../../util/MemoryUtil';\r\n\r\n// @dynamic\r\nexport class DisplayConvertor {\r\n  private _environment: IEnvironment = null;\r\n  private DATECHAR: number = 0;\r\n  private static _instance: DisplayConvertor = null;\r\n\r\n  static get Instance(): DisplayConvertor {\r\n    if (DisplayConvertor._instance === null) {\r\n      DisplayConvertor._instance = new DisplayConvertor();\r\n    }\r\n    return DisplayConvertor._instance;\r\n  }\r\n\r\n  constructor() {\r\n    this._environment = GuiEnvironment.Environment;\r\n  }\r\n\r\n  getNewDateBreakParams(): DateBreakParams {\r\n    return new DateBreakParams();\r\n  }\r\n\r\n  getNewTimeBreakParams(): TimeBreakParams {\r\n    return new TimeBreakParams();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string of a value from its picture format\r\n  /// </summary>\r\n  /// <param name = \"mgValue\">  the internal value (as sent in the XML)\r\n  /// </param>\r\n  /// <param name = \"rangeStr\"> value range\r\n  /// </param>\r\n  /// <param name = \"pic\">      the picture format\r\n  /// </param>\r\n  /// <returns> string to display\r\n  /// </returns>\r\n  mg2disp(mgValue: string, rangeStr: string, pic: PIC, useNative: boolean, compIdx: number, time_date_pic_Z_edt: boolean): any;\r\n  mg2disp(mgValue: string, rangeStr: string, pic: PIC, useNative: boolean, alwaysFill: boolean, compIdx: number, time_date_pic_Z_edt: boolean): any;\r\n  mg2disp(mgValue: string, rangeStr: string, pic: PIC, useNative: boolean, alwaysFill: boolean, compIdx: number, convertCase: boolean, time_date_num_pic_Z_edt: boolean): any;\r\n  mg2disp(mgValue: string, rangeStr: string, pic: PIC, useNative: boolean, compIdxOrAlwaysFill: any, time_date_pic_Z_edtOrCompIdx: any, time_date_pic_Z_edtOrConvertCase?: boolean, time_date_num_pic_Z_edt?: boolean): any {\r\n    if (arguments.length === 6)\r\n      return this.mg2disp_0(mgValue, rangeStr, pic, useNative, compIdxOrAlwaysFill, time_date_pic_Z_edtOrCompIdx);\r\n\r\n    else if (arguments.length === 7)\r\n      return this.mg2disp_1(mgValue, rangeStr, pic, useNative, compIdxOrAlwaysFill, time_date_pic_Z_edtOrCompIdx, time_date_pic_Z_edtOrConvertCase);\r\n\r\n    else\r\n      return this.mg2disp_2(mgValue, rangeStr, pic, useNative, compIdxOrAlwaysFill, time_date_pic_Z_edtOrCompIdx, time_date_pic_Z_edtOrConvertCase, time_date_num_pic_Z_edt);\r\n  }\r\n\r\n  private mg2disp_0(mgValue: string, rangeStr: string, pic: PIC, useNative: boolean, compIdx: number, time_date_pic_Z_edt: boolean): any {\r\n    return this.mg2disp(mgValue, rangeStr, pic, useNative, false, compIdx, time_date_pic_Z_edt);\r\n  }\r\n\r\n  private mg2disp_1(mgValue: string, rangeStr: string, pic: PIC, useNative: boolean, alwaysFill: boolean, compIdx: number, time_date_pic_Z_edt: boolean): any {\r\n    return this.mg2disp(mgValue, rangeStr, pic, useNative, alwaysFill, compIdx, false, time_date_pic_Z_edt);\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string of a value from its picture format\r\n  /// </summary>\r\n  /// <param name = \"mgValue\">the internal value (as sent in the XML)\r\n  /// </param>\r\n  /// <param name = \"rangeStr\">value range\r\n  /// </param>\r\n  /// <param name = \"pic\">the picture format\r\n  /// </param>\r\n  /// <param name = \"alwaysFill\">Always auto fill alpha over its picture (used for select controls)\r\n  /// </param>\r\n  /// <returns> string to display\r\n  /// </returns>\r\n  public mg2disp_2(mgValue: string, rangeStr: string, pic: PIC, useNative: boolean, alwaysFill: boolean, compIdx: number, convertCase: boolean, time_date_num_pic_Z_edt: boolean): any {\r\n    let str: string = \"\";\r\n    let tmpRange: string = (rangeStr === null) ? \"\" : rangeStr;\r\n\r\n    switch (pic.getAttr()) {\r\n\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n        str = this.fromAlpha(mgValue, pic, tmpRange, alwaysFill, convertCase);\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC: {\r\n\r\n        // Now, currecy directive supported, but this will be handled by angular packages like ng-currency\r\n        // here it should simply pass the actual native value of number and masks should not be applied\r\n        // So, prepare temporary picture to generate native value.\r\n        let  newPic = pic.getUnformattedNumericPic();\r\n\r\n        //store and restore decimal sep and thou. sep\r\n        let  dec: string = GuiEnvironment.Environment.GetDecimal();\r\n        let thou:string  = GuiEnvironment.Environment.GetThousands();\r\n\r\n        //set default values\r\n        GuiEnvironment.Environment.setDecimalSeparator('.');\r\n        GuiEnvironment.Environment.setThousandsSeparator(',');\r\n\r\n        str = this.fromNum(mgValue, newPic);\r\n        GuiEnvironment.Environment.setDecimalSeparator(dec);\r\n        GuiEnvironment.Environment.setThousandsSeparator(thou);\r\n        // Value should be trimmed when we are displaying control in order to display alignment properly. But while entering control, it should not be trimmed\r\n        // in order to read it properly.\r\n        if (newPic.getMaskChars() === 0 || !time_date_num_pic_Z_edt)\r\n          str = StrUtil.ltrim(str);\r\n\r\n        if (useNative) {\r\n          if (str == \"\")\r\n            return null;\r\n\r\n          let dbl: number = Number(str);\r\n          return dbl;\r\n        }\r\n        else\r\n          return str;\r\n      }\r\n      case StorageAttribute.DATE: {\r\n        if (useNative) {\r\n          let dt: Date;\r\n          dt = this.fromMgDateToNativeDate(mgValue, pic, compIdx);\r\n          return dt;\r\n        }\r\n        else {\r\n          str = this.fromDate(mgValue, pic, compIdx, time_date_num_pic_Z_edt);\r\n          break;\r\n        }\r\n      }\r\n      case StorageAttribute.TIME: {\r\n        if (useNative) {\r\n          let dt: Date;\r\n          dt = this.fromMgTimeToNativeTime(mgValue, pic);\r\n          return dt;\r\n        }\r\n        else {\r\n          str = this.fromTime(mgValue, pic, time_date_num_pic_Z_edt);\r\n          break;\r\n        }\r\n      }\r\n      case StorageAttribute.BOOLEAN: {\r\n        let logVal: boolean;\r\n        logVal = this.fromMgLogicalToNativeLogical(mgValue);\r\n        return logVal;\r\n      }\r\n\r\n      case StorageAttribute.BLOB:\r\n        str = BlobType.getString(mgValue);\r\n        break;\r\n      case StorageAttribute.BLOB_VECTOR:\r\n        str = mgValue;\r\n        break;\r\n    }\r\n    return str;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build an internal representation of a display value from its picture format\r\n  /// </summary>\r\n  /// <param name = \"dispValue\">the value as entered by user\r\n  /// </param>\r\n  /// <param name = \"rangeStr\">value range\r\n  /// </param>\r\n  /// <param name = \"pic\">the picture format\r\n  /// </param>\r\n  /// <param name = \"blobContentType\">if the attribute is blob, its content type\r\n  /// </param>\r\n  /// <returns> internal form of data (as used in the XML)\r\n  /// </returns>\r\n  disp2mg(dispValue: any, pic: PIC, compIdx: number, blobContentType: string): string {\r\n    let str: string = \"\";\r\n\r\n    switch (pic.getAttr()) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n        str = this.toAlpha(dispValue, pic);\r\n        break;\r\n\r\n\r\n      case StorageAttribute.NUMERIC: {\r\n        dispValue = String(dispValue);\r\n        // Remove the mask from display value.\r\n        let len: number = dispValue.length;\r\n        while (len > 0) {\r\n          if (!pic.picIsMask(len - 1) && dispValue[len - 1] !== (' '))\r\n            break;\r\n          len--;\r\n        }\r\n        if (dispValue.length > len)\r\n          dispValue = NString.Remove(dispValue, len, (dispValue.length - len));\r\n\r\n        if (pic.isNegative() && dispValue.trim().startsWith(\"-\"))\r\n          dispValue = StrUtil.ltrim(dispValue);\r\n\r\n        //store and restore decimal sep and thou. sep\r\n        let  dec: string = GuiEnvironment.Environment.GetDecimal();\r\n        let thou:string  = GuiEnvironment.Environment.GetThousands();\r\n\r\n        //set default values\r\n        GuiEnvironment.Environment.setDecimalSeparator('.');\r\n        GuiEnvironment.Environment.setThousandsSeparator(',');\r\n\r\n        // Now, currecy directive supported, but this will be handled by angular packages like ng-currency\r\n        // here it should simply pass the actual native value of number and masks should not be applied\r\n        // So, prepare temporary picture to generate native value.\r\n        let  newPic = pic.getUnformattedNumericPic();\r\n\r\n        str = this.toNum(dispValue, newPic, compIdx);\r\n\r\n        GuiEnvironment.Environment.setDecimalSeparator(dec);\r\n        GuiEnvironment.Environment.setThousandsSeparator(thou);\r\n      }\r\n        break;\r\n\r\n\r\n      case StorageAttribute.DATE:\r\n      {\r\n        let dt: Date;\r\n        //when date is in item list for choice ctrl, it will come here as string. so convert it to Date.\r\n        if (typeof dispValue === 'string')\r\n          dt = new Date (dispValue);\r\n        else\r\n          dt = dispValue;\r\n        str = this.fromNativeDateToMgDate(dt, pic);\r\n      }\r\n      break;\r\n\r\n\r\n      case StorageAttribute.TIME: {\r\n        let dt: Date;\r\n\r\n        //when date is in item list for choice ctrl, it will come here as string. so convert it to Date.\r\n        if (typeof dispValue === 'string')\r\n        {\r\n          dt = new Date();\r\n          if (dispValue !== null) {\r\n            dt.setHours(+String(dispValue).substr(0, 2));\r\n            dt.setMinutes(+String(dispValue).substr(0, 2));\r\n            if (String(dispValue).length > 5)\r\n              dt.setSeconds(+String(dispValue).substr(0, 2));\r\n          }\r\n        }\r\n\r\n        else\r\n          dt = dispValue;\r\n\r\n        str = this.fromNativeTimeToMgTime(dt);\r\n      }\r\n        break;\r\n\r\n\r\n      case StorageAttribute.BOOLEAN:\r\n        str = this.fromNativeLogicalToMgLogical(dispValue);\r\n        break;\r\n\r\n\r\n      case StorageAttribute.BLOB:\r\n        str = BlobType.createFromString(dispValue, blobContentType);\r\n        break;\r\n    }\r\n    return str;\r\n  }\r\n\r\n  // --------------------------------------------------------------------------\r\n  //  Methods for coverting INTERNAL ---> DIPLAY\r\n  // --------------------------------------------------------------------------\r\n\r\n  /// <summary>\r\n  ///   Handles magic number value\r\n  /// </summary>\r\n  /// <param name = \"mgNum\">   A Magic Number</param>\r\n  /// <param name = \"picStr\">  The picture to use</param>\r\n  /// <returns> the string to be displayed</returns>\r\n  public fromNum(mgValue: string, pic: PIC): string {\r\n    let mgNum: NUM_TYPE = new NUM_TYPE(mgValue);\r\n    return mgNum.toDisplayValue(pic);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string for an alpha value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   The source data\r\n  /// </param>\r\n  /// <param name = \"picStr\">    The picture to use for the value to display\r\n  /// </param>\r\n  /// <param name = \"rangeStr\">  The range of values to check\r\n  /// </param>\r\n  /// <param name = \"alwaysFill\">Always auto fill alpha over its picture (used for select controls)\r\n  /// </param>\r\n  /// <returns> the string to be displayed\r\n  /// </returns>\r\n  private fromAlpha(dataStr: string, pic: PIC, rangeStr: string, alwaysFill: boolean, convertCase: boolean): string {\r\n    let len: number = pic.getMaskSize();\r\n    let min_len: number = len;\r\n    let maskStr: string = pic.getMask();\r\n    let resStr: string;\r\n\r\n    if (pic.getMaskChars() > 0) {\r\n      resStr = this.win_data_cpy(NString.ToCharArray(maskStr), len, NString.ToCharArray(dataStr), pic.isAttrAlpha(), convertCase);\r\n    }\r\n    else {\r\n      if (UtilStrByteMode.isLocaleDefLangDBCS() && pic.isAttrAlpha())\r\n      // JPN: DBCS support\r\n      {\r\n        // substring by the number of bytes\r\n        let intDataStrLenB: number = UtilStrByteMode.lenB(dataStr);\r\n        if (min_len > intDataStrLenB) {\r\n          min_len = intDataStrLenB;\r\n        }\r\n        resStr = UtilStrByteMode.leftB(dataStr, min_len);\r\n      }\r\n      else if (dataStr !== null) {\r\n        if (min_len > dataStr.length) {\r\n          min_len = dataStr.length;\r\n        }\r\n        if (convertCase) {\r\n          resStr = this.win_data_cpy(NString.ToCharArray(maskStr), len, NString.ToCharArray(dataStr), pic.isAttrAlpha(), convertCase);\r\n        }\r\n        else {\r\n          resStr = dataStr.substr(0, min_len);\r\n        }\r\n      }\r\n    }\r\n\r\n    // We do not fill Alpha filed over control's picture length QCR # 295408\r\n    if (alwaysFill || (rangeStr !== null && rangeStr.length > 0 && resStr.length < len)) {\r\n      let vd: ValidationDetailsBase = new ValidationDetailsBase(rangeStr);\r\n      let continuousRangeValues: List<string> = vd.getContinuousRangeValues();\r\n      let discreteRangeValues: List<string> = vd.getDiscreteRangeValues();\r\n      if (continuousRangeValues !== null || discreteRangeValues !== null) {\r\n        resStr = this.fillAlphaByRange(continuousRangeValues, discreteRangeValues, resStr);\r\n      }\r\n    }\r\n    return resStr;\r\n  }\r\n\r\n  private caseConvertedChar(data: string, mask: string): string {\r\n\r\n    let ch: string;\r\n    if (mask.charCodeAt(0) === PICInterface.PIC_U) {\r\n      ch = data.toUpperCase();\r\n    }\r\n    else {\r\n      if (mask.charCodeAt(0) === PICInterface.PIC_L) {\r\n        ch = data.toLowerCase();\r\n      }\r\n      else {\r\n        ch = data;\r\n      }\r\n    }\r\n    return ch;\r\n  }\r\n\r\n  private win_data_cpy(maskStr: string[], maskLen: number, dataStr: string[], isAttrAlpha: boolean): string;\r\n  private win_data_cpy(maskStr: string[], maskLen: number, dataStr: string[], isAttrAlpha: boolean, convertCase: boolean): string;\r\n  private win_data_cpy(maskStr: any, maskLen: number, dataStr: any, isAttrAlpha: boolean, convertCase?: boolean): string {\r\n    if (arguments.length === 4)\r\n      return this.win_data_cpy_0(maskStr, maskLen, dataStr, isAttrAlpha);\r\n\r\n    return this.win_data_cpy_1(maskStr, maskLen, dataStr, isAttrAlpha, convertCase);\r\n  }\r\n\r\n  private win_data_cpy_0(maskStr: string[], maskLen: number, dataStr: string[], isAttrAlpha: boolean): string {\r\n    return this.win_data_cpy(maskStr, maskLen, dataStr, isAttrAlpha, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Handles alpha value\r\n  /// </summary>\r\n  /// <param name = \"maskStr\">   The mask to be used in order to build the string\r\n  /// </param>\r\n  /// <param name = \"picStr\">    The picture to use\r\n  /// </param>\r\n  /// <returns> the string to be displayed\r\n  /// </returns>\r\n  private win_data_cpy_1(maskStr: string[], maskLen: number, dataStr: string[], isAttrAlpha: boolean, convertCase: boolean): string {\r\n    let maskIdx: number = 0;\r\n    let dataIdx: number = 0;\r\n    let resStr: string[] = new Array<string>(maskLen);\r\n\r\n    if (isAttrAlpha && UtilStrByteMode.isLocaleDefLangDBCS()) {\r\n      let num2: number = 0;\r\n      while (maskIdx < maskLen && num2 < maskLen) {\r\n        if (maskStr[maskIdx].charCodeAt(0) <= PICInterface.PIC_MAX_OP) {\r\n          if (dataIdx < dataStr.length) {\r\n            let strVal: string = NString.FromChars(dataStr, dataIdx, 1);\r\n            if (UtilStrByteMode.lenB(strVal) === 2) {\r\n              if (maskIdx + 1 < maskLen) {\r\n                if (maskStr[maskIdx + 1].charCodeAt(0) <= PICInterface.PIC_MAX_OP) {\r\n                  if (convertCase) {\r\n                    resStr[num2++] = this.caseConvertedChar(dataStr[dataIdx++], maskStr[maskIdx + 1]);\r\n                  }\r\n                  else {\r\n                    resStr[num2++] = dataStr[dataIdx++];\r\n                  }\r\n                  maskIdx = maskIdx + 1;\r\n                }\r\n                else {\r\n                  resStr[num2++] = ' ';\r\n                }\r\n              }\r\n              else {\r\n                resStr[num2++] = ' ';\r\n              }\r\n            }\r\n            else {\r\n              if (convertCase) {\r\n                resStr[num2++] = this.caseConvertedChar(dataStr[dataIdx++], maskStr[maskIdx + 1]);\r\n              }\r\n              else {\r\n                resStr[num2++] = dataStr[dataIdx++];\r\n              }\r\n            }\r\n          }\r\n          else {\r\n            resStr[num2++] = ' '/*' '*/;\r\n          }\r\n        }\r\n        else {\r\n          resStr[num2++] = maskStr[maskIdx];\r\n        }\r\n        maskIdx = maskIdx + 1;\r\n      }\r\n      return NString.FromChars(resStr).substr(0, num2);\r\n    }\r\n\r\n    while (maskIdx < maskLen) {\r\n      if (maskStr[maskIdx].charCodeAt(0) <= PICInterface.PIC_MAX_OP) {\r\n        if (dataIdx < dataStr.length) {\r\n          resStr[maskIdx] = dataStr[dataIdx];\r\n          if (convertCase) {\r\n            resStr[maskIdx] = this.caseConvertedChar(dataStr[dataIdx], maskStr[maskIdx]);\r\n          }\r\n          else {\r\n            resStr[maskIdx] = dataStr[dataIdx];\r\n          }\r\n          dataIdx = dataIdx + 1;\r\n        }\r\n        else {\r\n          resStr[maskIdx] = ' '/*' '*/;\r\n        }\r\n      }\r\n      else {\r\n        resStr[maskIdx] = maskStr[maskIdx];\r\n      }\r\n      maskIdx = maskIdx + 1;\r\n    }\r\n    return NString.FromChars(resStr);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string for an date value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   The source data</param>\r\n  /// <param name = \"picStr\">    The picture to use for the value to display</param>\r\n  /// <returns> the string to be displayed</returns>\r\n  fromDate(dataStr: string, pic: PIC, compIdx: number, time_date_pic_Z_edt: boolean): string {\r\n    let mask: string = pic.getMask();\r\n    let maskSize: number = pic.getMaskSize();\r\n    let date: number = new NUM_TYPE(dataStr).NUM_2_ULONG();\r\n    return this.to_a_pic_datemode(mask, maskSize, date, pic, time_date_pic_Z_edt, false, compIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string for an time value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   The source data</param>\r\n  /// <param name = \"picStr\">    The picture to use for the value to display</param>\r\n  /// <returns> the string to be displayed</returns>\r\n  fromTime(dataStr: string, pic: PIC, time_date_pic_Z_edt: boolean): string {\r\n    let mask: string = pic.getMask();\r\n    let maskSize: number = pic.getMaskSize();\r\n    let time: number = new NUM_TYPE(dataStr).NUM_2_ULONG();\r\n    return this.time_2_a_pic(mask, maskSize, time, pic, time_date_pic_Z_edt, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string for the date value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   The source data</param>\r\n  /// <param name = \"picStr\">    The picture to use for the value to display</param>\r\n  /// <returns> the string to be displayed</returns>\r\n  fromMgDateToNativeDate(dataStr: string, pic: PIC, compIdx: number): Date {\r\n\r\n    let date: number = new NUM_TYPE(dataStr).NUM_2_ULONG();\r\n    let breakParams: DateBreakParams;\r\n    // Break data into its components\r\n    breakParams = new DateBreakParams();\r\n    this.date_break_datemode(breakParams, date, false, compIdx);\r\n    if (breakParams.month > 0)\r\n      breakParams.month = breakParams.month - 1; //month is 0 based in Date class\r\n\r\n    if (breakParams.year == 0 && breakParams.month == 0 && breakParams.day == 0)\r\n      return null;\r\n\r\n    return new Date(breakParams.year, breakParams.month, breakParams.day);\r\n\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Build a display string for an date value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   The source data</param>\r\n  /// <param name = \"picStr\">    The picture to use for the value to display</param>\r\n  /// <returns> the string to be displayed</returns>\r\n  fromNativeDateToMgDateNumber(nativeDate: Date, pic: PIC): number {\r\n    let numVal: number;\r\n    let dateParams: DateBreakParams;\r\n    let millenium: number = 0;\r\n    let year: number = nativeDate.getFullYear();\r\n    let day: number = nativeDate.getDate();\r\n    let month: number = nativeDate.getMonth() + 1;\r\n\r\n    // Hebrew Year\r\n    if (pic.isHebrew()) {\r\n      if (year > 0) {\r\n        if (millenium === 0)\r\n          millenium = 5;\r\n        year += millenium * 1000;\r\n      }\r\n      numVal = (HebrewDate.dateheb_2_d(year, month, day));\r\n    }\r\n    else {\r\n      // the next 2 lines support 4.xx DD/MM pictures\r\n      if (year === 0) {\r\n        dateParams = this.date_sys();\r\n        year = dateParams.year;\r\n      }\r\n\r\n      numVal = this.date_4_calender(year, month, day, 0, false);    // we are adding a little empty space to the variable, because we might later\r\n    }\r\n    return numVal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string for an date value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   The source data</param>\r\n  /// <param name = \"picStr\">    The picture to use for the value to display</param>\r\n  /// <returns> the string to be displayed</returns>\r\n  fromNativeDateToMgDate(nativeDate: Date, pic: PIC): string {\r\n\r\n    let mgNum: NUM_TYPE = new NUM_TYPE();\r\n    let numVal: number = nativeDate == null ? 0 : this.fromNativeDateToMgDateNumber(nativeDate, pic);\r\n    mgNum.NUM_4_LONG(numVal);\r\n\r\n    return mgNum.toXMLrecord();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Handle date value\r\n  /// </summary>\r\n  /// <param name = \"outStr\">          The mask to be used\r\n  /// </param>\r\n  /// <param name = \"out_len\">         Mask length\r\n  /// </param>\r\n  /// <param name = \"pic\">             The picure information\r\n  /// </param>\r\n  /// <param name = \"date_pic_Z_edt\">\r\n  /// </param>\r\n  /// <param name = \"ignore_dt_fmt\">\r\n  /// </param>\r\n  /// <returns> the string to be displayed\r\n  /// </returns>\r\n  to_a_pic_datemode(outStr: string, out_len: number, date: number, pic: PIC, date_pic_Z_edt: boolean, ignore_dt_fmt: boolean, compIdx: number): string {\r\n    let len: number;\r\n    let day: number = 0;\r\n    let doy: number = 0;\r\n    let dow: number = 0;\r\n    let year: number = 0;\r\n    let month: number = 0;\r\n    let hday: number = 0;\r\n    let hyear: number = 0;\r\n    let hmonth: number = 0;\r\n    let leap: Boolean = false;\r\n    let i: number;\r\n    let p: string[];\r\n    let outVal: string[] = NString.ToCharArray(outStr);\r\n    let breakParams: DateBreakParams;\r\n    let dateNameParams: DateNameParams;\r\n    let outIdx: number = 0;\r\n    let strOut: string = null;\r\n\r\n    // If result overflows return buffer, fill with asterixs and bail out\r\n    if (pic.getMaskSize() > out_len) {\r\n      for (; i < out_len; i++)\r\n        outVal[i] = '*';\r\n      return NString.FromChars(outVal);\r\n    }\r\n\r\n    // If zero fill requested and date value is zero, fill it and bail out\r\n    out_len = len = pic.getMaskSize();\r\n    if (pic.zeroFill() && date === 0 && !date_pic_Z_edt) {\r\n      for (; i < out_len; i++)\r\n        outVal[i] = pic.getZeroPad();\r\n      return NString.FromChars(outVal);\r\n    }\r\n    if (pic.isHebrew() && (date === 0 || date === 1000000000)) {\r\n      for (; i < out_len; i++)\r\n        outVal[i] = ' ';\r\n      return NString.FromChars(outVal);\r\n    }\r\n\r\n    // Break data into its components\r\n    breakParams = new DateBreakParams(year, month, day, doy, dow);\r\n    this.date_break_datemode(breakParams, date, ignore_dt_fmt, compIdx);\r\n    if (pic.isHebrew()) {\r\n      let refhday: RefParam<number> = new RefParam<number>(hday);\r\n      let refhmonth: RefParam<number> = new RefParam<number>(hmonth);\r\n      let refhyear: RefParam<number> = new RefParam<number>(hyear);\r\n      leap = HebrewDate.dateheb_4_d(date, refhday, refhmonth, refhyear);\r\n\r\n      hday = refhday.value;\r\n      hmonth = refhmonth.value;\r\n      hyear = refhyear.value;\r\n    }\r\n\r\n    year = breakParams.year;\r\n    month = breakParams.month;\r\n    day = breakParams.day;\r\n    doy = breakParams.doy;\r\n    dow = breakParams.dow;\r\n    breakParams = null;\r\n    while (len > 0) {\r\n      let refOutLen: RefParam<number> = new RefParam<number>(out_len);\r\n      switch (outVal[outIdx].charCodeAt(0)) {\r\n        case PICInterface.PIC_YY:\r\n          if (pic.zeroFill() && date === 0 && date_pic_Z_edt)\r\n            MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);\r\n          else\r\n            this.int_2_a(outVal, outIdx, 2, year, '0');\r\n          outIdx += 2;\r\n          len -= 2;\r\n          break;\r\n        case PICInterface.PIC_HYYYYY:\r\n          i = HebrewDate.dateheb_2_str(outVal, outIdx, len, refOutLen, 5, hyear, pic.isTrimed(), true);\r\n          out_len = refOutLen.value;\r\n          outIdx += i;\r\n          len -= i;\r\n          break;\r\n        case PICInterface.PIC_HL:\r\n          i = HebrewDate.dateheb_i_2_h((hyear / 1000) % 10, outVal, outIdx, false, false);\r\n          outIdx++;\r\n          len--;\r\n          break;\r\n        case PICInterface.PIC_HDD:\r\n          i = HebrewDate.dateheb_2_str(outVal, outIdx, len, refOutLen, 2, hday, pic.isTrimed(), false);\r\n          out_len = refOutLen.value;\r\n          outIdx += i;\r\n          len -= i;\r\n          break;\r\n        case PICInterface.PIC_YYYY:\r\n          if (pic.zeroFill() && date === 0 && date_pic_Z_edt)\r\n            MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 4);\r\n          else\r\n            this.int_2_a(outVal, outIdx, 4, year, '0');\r\n          outIdx += 4;\r\n          len -= 4;\r\n          break;\r\n        case PICInterface.PIC_MMD:\r\n          if (pic.zeroFill() && date === 0 && date_pic_Z_edt)\r\n            MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);\r\n          else\r\n            this.int_2_a(outVal, outIdx, 2, month, '0');\r\n          outIdx += 2;\r\n          len -= 2;\r\n          break;\r\n        case PICInterface.PIC_MMM:\r\n          if (pic.isHebrew()) {\r\n            if (leap && hmonth === 6)\r\n              hmonth = 14;\r\n            let monthNames: string[] = HebrewDate.GetLocalMonths();\r\n            p = NString.ToCharArray(monthNames[hmonth]);\r\n          }\r\n          else {\r\n            let monthStr: string = Events.GetMessageString(MsgInterface.MONTHS_PTR);\r\n            let monthNames: string[] = DateUtil.getLocalMonths(monthStr);\r\n            p = NString.ToCharArray(monthNames[month]);\r\n          }\r\n          dateNameParams = new DateNameParams(outVal, outIdx, len);\r\n          out_len -= this.date_i_2_nm(dateNameParams, p, pic.isTrimed());\r\n          outIdx = dateNameParams.outIdx;\r\n          len = dateNameParams.len;\r\n          dateNameParams = null;\r\n          break;\r\n        case PICInterface.PIC_DD:\r\n          let isZero: boolean = pic.zeroFill();\r\n          if (isZero && date === 0 && date_pic_Z_edt)\r\n            MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);\r\n          else\r\n            this.int_2_a(outVal, outIdx, 2, day, '0');\r\n          outIdx += 2;\r\n          len -= 2;\r\n          break;\r\n        case PICInterface.PIC_DDD:\r\n          if (pic.zeroFill() && date === 0 && date_pic_Z_edt)\r\n            MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 3);\r\n          else\r\n            this.int_2_a(outVal, outIdx, 3, doy, '0');\r\n          len -= 3;\r\n          outIdx += 3;\r\n          break;\r\n        case PICInterface.PIC_DDDD:\r\n          i = this.date_2_DDDD(day, outVal, outIdx, len, pic.isTrimed());\r\n          outIdx += i;\r\n          out_len += i - 4;\r\n          len -= 4;\r\n          break;\r\n        case PICInterface.PIC_W:\r\n          if (pic.zeroFill() && date === 0 && date_pic_Z_edt)\r\n            MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 1);\r\n          else\r\n            this.int_2_a(outVal, outIdx, 1, dow, '0');\r\n          len--;\r\n          outIdx++;\r\n          break;\r\n        case PICInterface.PIC_WWW:\r\n          if (pic.isHebrew()) {\r\n            let dowsNames: string[] = HebrewDate.GetLocalDows();\r\n            p = NString.ToCharArray(dowsNames[dow]);\r\n          }\r\n          else {\r\n            let dayStr: string = Events.GetMessageString(MsgInterface.DAYS_PTR);\r\n            let dayNames: string[] = DateUtil.getLocalDays(dayStr);\r\n            p = NString.ToCharArray(dayNames[dow]);\r\n          }\r\n          dateNameParams = new DateNameParams(outVal, outIdx, len);\r\n          out_len -= this.date_i_2_nm(dateNameParams, p, pic.isTrimed());\r\n          outIdx = dateNameParams.outIdx;\r\n          len = dateNameParams.len;\r\n          dateNameParams = null;\r\n          break;\r\n        case PICInterface.PIC_BB: // JPN: Japanese date picture support\r\n          // Japanese day of the week\r\n          p = NString.ToCharArray(UtilDateJpn.getStrDow(dow));\r\n          strOut = null;\r\n          dateNameParams = new DateNameParams(outVal, outIdx, len);\r\n          strOut = this.date_i_2_nm_bytemode(strOut, dateNameParams, NString.FromChars(p), out_len);\r\n          outVal = new Array(strOut.length);\r\n          NString.CopyTo(strOut, 0, outVal, 0, strOut.length);\r\n\r\n          outIdx = dateNameParams.outIdx;\r\n          len = dateNameParams.len;\r\n          strOut = null;\r\n          dateNameParams = null;\r\n          break;\r\n        case PICInterface.PIC_JY1:\r\n        case PICInterface.PIC_JY2:\r\n        case PICInterface.PIC_JY4:\r\n          // Japanese the name of an era\r\n          let strNum: string = null;\r\n          if (outVal[outIdx].charCodeAt(0) === PICInterface.PIC_JY1)\r\n            strNum = UtilDateJpn.getInstance().date_jpn_yr_2_a(year, doy, false);\r\n          else\r\n            strNum = UtilDateJpn.getInstance().date_jpn_yr_2_a(year, doy, true);\r\n          strOut = null;\r\n          dateNameParams = new DateNameParams(outVal, outIdx, len);\r\n          strOut = this.date_i_2_nm_bytemode(strOut, dateNameParams, strNum, out_len);\r\n          outVal = null;\r\n          outVal = new Array(strOut.length);\r\n          NString.CopyTo(strOut, 0, outVal, 0, strOut.length);\r\n          outIdx = dateNameParams.outIdx;\r\n          len = dateNameParams.len;\r\n          strOut = null;\r\n          dateNameParams = null;\r\n          break;\r\n        case PICInterface.PIC_YJ:\r\n          if (pic.zeroFill() && date === 0 && date_pic_Z_edt)\r\n            MemoryUtil.char_memset(outVal, outIdx, pic.getZeroPad(), 2);\r\n          else\r\n            this.int_2_a(outVal, outIdx, 2, UtilDateJpn.getInstance().date_jpn_year_ofs(year, doy), '0');\r\n          outIdx += 2;\r\n          len -= 2;\r\n          break;\r\n        default:\r\n          outIdx++;\r\n          len--;\r\n          break;\r\n      }\r\n    }\r\n    if (out_len < outVal.length)\r\n      MemoryUtil.char_memset(outVal, out_len, ' ', outVal.length - out_len);\r\n\r\n    return NString.FromChars(outVal);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Break a date into Year, Month, Day in month, Day in year and Day in week\r\n  /// </summary>\r\n  date_break_datemode(breakParams: DateBreakParams, date: number, ignore_dt_fmt: boolean, compIdx: number): void {\r\n\r\n    let year: number = breakParams.year;\r\n    let month: number = breakParams.month;\r\n    let day: number = breakParams.day;\r\n    let doy: number = breakParams.doy;\r\n    let dow: number = breakParams.dow;\r\n\r\n    if (date <= 0) {\r\n      breakParams.day = 0;\r\n      breakParams.doy = 0;\r\n      breakParams.dow = 0;\r\n      breakParams.year = 0;\r\n      breakParams.month = 0;\r\n    }\r\n    else {\r\n      dow = date % 7 + 1;\r\n      date = date - 1;\r\n      let cent4: number = Math.floor(date / PICInterface.DAYSINFOURCENT);\r\n      date = date - cent4 * PICInterface.DAYSINFOURCENT;\r\n      let cent: number = Math.floor(date / PICInterface.DAYSINCENTURY);\r\n      if (cent > 3) {\r\n        cent = 3;\r\n      }\r\n      date = date - cent * PICInterface.DAYSINCENTURY;\r\n      let year4: number = Math.floor(date / PICInterface.DAYSINFOURYEAR);\r\n      date = date - year4 * PICInterface.DAYSINFOURYEAR;\r\n      year = Math.floor(date / PICInterface.DAYSINYEAR);\r\n      if (year > 3) {\r\n        year = 3;\r\n      }\r\n      date = date - year * PICInterface.DAYSINYEAR;\r\n      year = cent4 * 400 + cent * 100 + year4 * 4 + year + 1;\r\n      let leapyear: number = 0;\r\n      if (year % 4 === 0) {\r\n        if (year % 100 !== 0 || year % 400 === 0) {\r\n          leapyear = 1;\r\n        }\r\n      }\r\n\r\n      if (!ignore_dt_fmt && this._environment.GetDateMode(compIdx) === 'B') {\r\n        year = year + PICInterface.DATE_BUDDHIST_GAP;\r\n      }\r\n      month = (Math.floor(date / PICInterface.DAYSINMONTH) + 1);\r\n      day = PICInterface.date_day_tab[month];\r\n      if (leapyear > 0) {\r\n        if (month > 1) {\r\n          day = day + 1;\r\n        }\r\n      }\r\n\r\n      if (date >= day) {\r\n        month = month + 1;\r\n      }\r\n      else {\r\n        day = PICInterface.date_day_tab[month - 1];\r\n        if (leapyear > 0) {\r\n          if (month > 2) {\r\n            day = day + 1;\r\n          }\r\n        }\r\n      }\r\n      day = date - day + 1;\r\n      doy = date + 1;\r\n      breakParams.year = year;\r\n      breakParams.month = month;\r\n      breakParams.day = day;\r\n      breakParams.doy = doy;\r\n      breakParams.dow = dow;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get alpha string from int value\r\n  /// </summary>\r\n  /// <param name = \"str\">     the output string (as an char array)\r\n  /// </param>\r\n  /// <param name = \"strPos\">  starting position\r\n  /// </param>\r\n  /// <param name = \"len\">     string length\r\n  /// </param>\r\n  /// <param name = \"n\">       the number to convert\r\n  /// </param>\r\n  /// <param name = \"lead\">    leading character\r\n  /// </param>\r\n  /// <returns> the result string length\r\n  /// </returns>\r\n  private int_2_a(str: string[], strPos: number, len: number, n: number, lead: string): number {\r\n    let neg: boolean = n < 0;\r\n\r\n    if (len <= 0)\r\n      return;\r\n\r\n    n = Math.abs(n);\r\n    let pos: number = len;\r\n\r\n    do {\r\n      str[strPos + (pos = pos - 1)] = String.fromCharCode(48 + n % 10);\r\n      n = Math.floor(n / 10);\r\n    }\r\n    while (pos > 0 && n > 0);\r\n\r\n    if (neg && pos > 0) {\r\n      str[strPos + (pos = pos - 1)] = '-'/*'-'*/;\r\n    }\r\n    return this.lib_a_fill(str, strPos, len, pos, lead.charCodeAt(0));\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Fill the char array for the converting of int->string\r\n  /// </summary>\r\n  /// <param name = \"str\">     the output string (as an char array)\r\n  /// </param>\r\n  /// <param name = \"strPos\">  starting position\r\n  /// </param>\r\n  /// <param name = \"len\">     string length\r\n  /// </param>\r\n  /// <param name = \"lead\">    leading character\r\n  /// </param>\r\n  /// <returns> the result string length\r\n  /// </returns>\r\n  private lib_a_fill(str: string[], strPos: number, len: number, pos: number, lead: number): number {\r\n\r\n    if (lead === 0) {\r\n      len = len - pos;\r\n\r\n      if (len > 0 && pos > 0) {\r\n        MemoryUtil.char_memcpy(str, strPos, str, pos, len);\r\n        MemoryUtil.char_memset(str, strPos + len, ' ', /*' '*/pos);\r\n      }\r\n    }\r\n    else {\r\n      if (pos > 0) {\r\n        MemoryUtil.char_memset(str, strPos, String.fromCharCode(lead), pos);\r\n      }\r\n    }\r\n    return len;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Convert index to Name\r\n  /// </summary>\r\n  /// <param name = \"dateNameParams\">  output sting details\r\n  /// </param>\r\n  /// <param name = \"nm\">              name\r\n  /// </param>\r\n  /// <param name = \"trim\">            output string should be trimed\r\n  /// </param>\r\n  /// </param>\r\n  /// <returns> the length of the string\r\n  /// </returns>\r\n  private date_i_2_nm(dateNameParams: DateNameParams, nm: string[], trim: boolean): number {\r\n\r\n    let n: number = this.date_msk_cnt(dateNameParams.outVal, dateNameParams.outIdx, <number>dateNameParams.len);\r\n    let l: number;\r\n    if (trim) {\r\n      l = MemoryUtil.mem_trim(nm, 0, n);\r\n    }\r\n    else {\r\n      l = n;\r\n    }\r\n    l = Math.min(l, dateNameParams.len);\r\n    MemoryUtil.char_memcpy(dateNameParams.outVal, dateNameParams.outIdx, nm, 0, l);\r\n    dateNameParams.outIdx = dateNameParams.outIdx + l;\r\n    dateNameParams.len = dateNameParams.len - n;\r\n\r\n    // -----------------------------------------------------------------------\r\n    // Trimed ? Jump other trimed mask : nothing\r\n    // -----------------------------------------------------------------------\r\n\r\n    n = n - l;\r\n\r\n    if (n > 0) {\r\n      MemoryUtil.char_memcpy(dateNameParams.outVal, dateNameParams.outIdx, dateNameParams.outVal, dateNameParams.outIdx + n, dateNameParams.len);\r\n    }\r\n    return <number>n;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   JPN: Japanese date picture support\r\n  ///   Convert index to Name\r\n  /// </summary>\r\n  /// <param name = \"strOut\">          output sting (original)\r\n  /// </param>\r\n  /// <param name = \"dateNameParams\">  output sting details\r\n  /// </param>\r\n  /// <param name = \"strNm\">           name which will be embedded in output string\r\n  /// </param>\r\n  /// <param name = \"intOutLen\">       the remaining length of the output string\r\n  /// </param>\r\n  /// <returns>                 output sting (processed)\r\n  /// </returns>\r\n  private date_i_2_nm_bytemode(strOut: string, dateNameParams: DateNameParams, strNm: string, intOutLen: number): string {\r\n    let intMskCnt: number = this.date_msk_cnt(dateNameParams.outVal, dateNameParams.outIdx, <number>dateNameParams.len);\r\n    let strWork: string = NString.FromChars(dateNameParams.outVal);\r\n\r\n    strWork = strWork.substr(0, dateNameParams.outIdx);\r\n\r\n    let intOfs: number = UtilStrByteMode.lenB(strWork);\r\n    strNm = UtilStrByteMode.leftB(strNm, intMskCnt);\r\n    strOut = UtilStrByteMode.repB(NString.FromChars(dateNameParams.outVal), strNm, intOfs + 1, intMskCnt);\r\n\r\n    dateNameParams.outIdx = dateNameParams.outIdx + strNm.length;\r\n    dateNameParams.len = dateNameParams.len - intMskCnt;\r\n    intOutLen = intOutLen - intMskCnt;\r\n    return strOut;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Return N of consecutive Mask characters\r\n  /// </summary>\r\n  /// <param name = \"msk\">     the mask to check\r\n  /// </param>\r\n  /// <param name = \"mskPos\">  index of first char to check\r\n  /// </param>\r\n  /// <param name = \"len\">     length of the mask\r\n  /// </param>\r\n  /// <returns> number of consecutive Mask characters\r\n  /// </returns>\r\n  private date_msk_cnt(msk: string[], mskPos: number, len: number): number {\r\n    let c: string = msk[mskPos++];\r\n    let i: number = 1;\r\n    while (<number>i < len) {\r\n      if (msk[mskPos] !== c) {\r\n        break;\r\n      }\r\n      mskPos = mskPos + 1;\r\n      i = i + 1;\r\n    }\r\n    return i;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Compute Day name\r\n  /// </summary>\r\n  private date_2_DDDD(day: number, outVal: string[], outIdx: number, len: number, trim: boolean): number {\r\n\r\n\r\n    let ret: number = 4;\r\n    let ext: string[];\r\n\r\n    if (day > 9) {\r\n      this.int_2_a(outVal, outIdx, 2, day, (<number>0).toString());\r\n      outIdx += 2;\r\n    }\r\n    else {\r\n      if (trim) {\r\n        MemoryUtil.char_memcpy(outVal, outIdx, outVal, outIdx + 1, len - 1);\r\n        /*17-May-90*/\r\n        ret--;\r\n      }\r\n      else {\r\n        // *(out++) = ' '; // Original Line\r\n        outVal[outIdx++] = ' ';\r\n      }\r\n      this.int_2_a(outVal, outIdx, 1, day, (<number>0).toString());\r\n      outIdx++;\r\n    }\r\n    switch (day) {\r\n      case 1:\r\n      case 21:\r\n      case 31:\r\n        ext = NString.ToCharArray(\"st\");\r\n        break;\r\n\r\n      case 2:\r\n      case 22:\r\n        ext = NString.ToCharArray(\"nd\");\r\n        break;\r\n\r\n      case 3:\r\n      case 23:\r\n        ext = NString.ToCharArray(\"rd\");\r\n        break;\r\n\r\n      default:\r\n        ext = NString.ToCharArray(\"th\");\r\n        break;\r\n    }\r\n    outVal[outIdx++] = ext[0];\r\n    outVal[outIdx] = ext[1];\r\n\r\n    return (ret);\r\n\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Build a display string for an time value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   The source data</param>\r\n  /// <param name = \"picStr\">    The picture to use for the value to display</param>\r\n  /// <returns> the string to be displayed</returns>\r\n  fromMgTimeToNativeTime(dataStr: string, pic: PIC): Date {\r\n    let time: number = new NUM_TYPE(dataStr).NUM_2_ULONG();\r\n    let breakParams: TimeBreakParams = new TimeBreakParams();\r\n\r\n    DisplayConvertor.time_break(breakParams, time);\r\n\r\n    let nativeDt: Date = new Date(0);\r\n\r\n    let maskStr = pic.getMask();\r\n    let outVal: string[] = NString.ToCharArray(maskStr);\r\n    let len = pic.getMaskSize();\r\n    let outIdx = 0;\r\n\r\n    while (len > 0) {\r\n      switch (outVal[outIdx].charCodeAt(0)) {\r\n        case (PICInterface.PIC_HH):\r\n          nativeDt.setHours(breakParams.hour);\r\n          outIdx += 2;\r\n          len -= 2;\r\n          break;\r\n        case (PICInterface.PIC_MMT):\r\n          nativeDt.setMinutes(breakParams.minute);\r\n          outIdx += 2;\r\n          len -= 2;\r\n          break;\r\n\r\n        case (PICInterface.PIC_SS):\r\n          nativeDt.setSeconds(breakParams.second);\r\n          outIdx += 2;\r\n          len -= 2;\r\n          break;\r\n        default:\r\n          outIdx ++;\r\n          len --;\r\n      }\r\n    }\r\n\r\n    return nativeDt;  }\r\n\r\n  /// <summary>\r\n  ///   Handle time value\r\n  /// </summary>\r\n  /// <param name = \"AsciiStr\">        The mask to be used</param>\r\n  /// <param name = \"AsciiL\">          Mask length</param>\r\n  /// <param name = \"pic\">             The picure information</param>\r\n  /// <param name = \"time_pic_Z_edt\"></param>\r\n  /// <param name = \"seconds\">/ milliSeconds flag</param>\r\n  /// <returns> the string to be displayed\r\n  /// </returns>\r\n  private time_2_a_pic(AsciiStr: string, AsciiL: number, time: number, pic: PIC, time_pic_Z_edt: boolean, milliSeconds: boolean): string {\r\n\r\n    // Original vars\r\n    let hour: number = 0;\r\n    let minute: number = 0;\r\n    let second: number = 0;\r\n    let millisec: number = 0;\r\n\r\n    let Ascii: string[] = NString.ToCharArray(AsciiStr);\r\n    let breakParams: TimeBreakParams = new TimeBreakParams(hour, minute, second);\r\n    let timeSec: number;\r\n    if (milliSeconds) {\r\n      timeSec = Math.floor(time / 1000);\r\n      millisec = time - timeSec * 1000;\r\n    }\r\n    else {\r\n      timeSec = time;\r\n    }\r\n\r\n    DisplayConvertor.time_break(breakParams, timeSec);\r\n    hour = breakParams.hour;\r\n    minute = breakParams.minute;\r\n    second = breakParams.second;\r\n\r\n    // If ascii representation overflows output buffer\r\n    // fill with '*' and bail out\r\n\r\n    let result: string;\r\n    if (pic.getMaskSize() > AsciiL) {\r\n      MemoryUtil.char_memset(Ascii, 0, '*', /*'*'*/AsciiL);\r\n      result = NString.FromChars(Ascii);\r\n    }\r\n    else {\r\n      if (pic.zeroFill()) {\r\n        if (timeSec === 0 && (!milliSeconds || millisec === 0)) {\r\n          if (time_pic_Z_edt) {\r\n            for (let intx: number = 0; intx < pic.getMaskSize(); intx = intx + 1) {\r\n              if (Ascii[intx] <= '\\u001f') {\r\n                Ascii[intx] = pic.getZeroPad();\r\n              }\r\n            }\r\n            result = NString.FromChars(Ascii);\r\n            return result;\r\n          }\r\n          MemoryUtil.char_memset(Ascii, 0, pic.getZeroPad(), pic.getMaskSize());\r\n          result = NString.FromChars(Ascii);\r\n          return result;\r\n        }\r\n      }\r\n      let I: number = 0;\r\n      let am: number = 0;\r\n      let len: number = pic.getMaskSize();\r\n      let HourI: number = -1;\r\n\r\n      while (I < len) {\r\n        switch (Ascii[I].charCodeAt(0)) {\r\n          case (PICInterface.PIC_HH):\r\n            HourI = I;\r\n            I += 2;\r\n            break;\r\n\r\n\r\n          case (PICInterface.PIC_MMT):\r\n            this.int_2_a(Ascii, I, 2, minute, '0');\r\n            I += 2;\r\n            break;\r\n\r\n          case (PICInterface.PIC_SS):\r\n            this.int_2_a(Ascii, I, 2, second, '0');\r\n            I += 2;\r\n            break;\r\n\r\n          case (PICInterface.PIC_MS):\r\n            this.int_2_a(Ascii, I, 3, millisec, '0');\r\n            I += 3;\r\n            break;\r\n\r\n          case (PICInterface.PIC_PM):\r\n            am = 1;\r\n            let tmpHour: number = hour % 24;\r\n            if (tmpHour < 12 || tmpHour === 0)\r\n              MemoryUtil.char_memcpy(Ascii, I, NString.ToCharArray(\"am\"), 0, 2);\r\n            else\r\n              MemoryUtil.char_memcpy(Ascii, I, NString.ToCharArray(\"pm\"), 0, 2);\r\n            I += 2;\r\n            break;\r\n\r\n          default:\r\n            I++;\r\n            break;\r\n        }\r\n      }\r\n      if (HourI >= 0) {\r\n        if (am > 0) {\r\n          hour = hour % 24;\r\n          if (hour === 0) {\r\n            hour = 12;\r\n          }\r\n          else {\r\n            hour = hour % 12;\r\n            if (hour === 0) {\r\n              hour = 12;\r\n            }\r\n          }\r\n        }\r\n        this.int_2_a(Ascii, HourI, 2, hour, (am !== 0 && hour < 10) ? ' ' : /*' '*/'0'/*'0'*/);\r\n      }\r\n      result = NString.FromChars(Ascii);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Break time into its components\r\n  /// </summary>\r\n  static time_break(breakParams: TimeBreakParams, time: number): void {\r\n\r\n    if (time <= 0) {\r\n      breakParams.second = 0;\r\n      breakParams.minute = 0;\r\n      breakParams.hour = 0;\r\n    }\r\n    else {\r\n      breakParams.hour = Math.floor(time / 3600);\r\n      time = time - breakParams.hour * 3600;\r\n      breakParams.minute = Math.floor(time / 60);\r\n      breakParams.second = time - breakParams.minute * 60;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a display string for a logical value according to the picture\r\n  /// </summary>\r\n  /// <param name = \"dataStr\">   \"0\" for false or \"1\" for true\r\n  /// </param>\r\n  /// <returns> boolean\r\n  /// </returns>\r\n  private fromMgLogicalToNativeLogical(dataStr: string): boolean {\r\n\r\n    let nativeVal: boolean;\r\n    nativeVal = (dataStr.charAt(0) === '1') ? true : false;\r\n    return nativeVal;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Build a mg string for a logical value according to the boolean value\r\n  /// </summary>\r\n  /// <param name = \"dispVal\">  boolean\r\n  /// </param>\r\n  /// <returns> string\r\n  /// </returns>\r\n  private fromNativeLogicalToMgLogical(dispVal: boolean): string {\r\n\r\n    let mgVal: string;\r\n    mgVal = (dispVal === true) ? \"1\" : \"0\";\r\n\r\n    return mgVal;\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   Get the default range for logical values\r\n  /// </summary>\r\n  /// <param name = \"rng\">  current range</param>\r\n  /// <returns> the default range if the input range is empty</returns>\r\n  private win_rng_bool(rng: string): string {\r\n\r\n    if (rng === null || rng.length === 0) {\r\n      rng = \"True, False\";\r\n    }\r\n    return rng;\r\n  }\r\n\r\n\r\n  // --------------------------------------------------------------------------\r\n  // Methods for coverting DIPLAY ---> INTERNAL\r\n  // --------------------------------------------------------------------------\r\n\r\n  /// <summary>\r\n  ///   Translates a string number to magic number\r\n  /// </summary>\r\n  /// <param name = \"dispValue\">   A string number</param>\r\n  /// <param name = \"picStr\">      The picture to use</param>\r\n  /// <returns> the magic number</returns>\r\n  toNum(dispValue: string, pic: PIC, compIdx: number): string {\r\n    let mgNum: NUM_TYPE = new NUM_TYPE(dispValue, pic, compIdx);\r\n    return mgNum.toXMLrecord();\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   builds the date magic number from the string value\r\n  /// </summary>\r\n  /// <param name = \"str\">            the date string</param>\r\n  /// <param name = \"str_len\">        length of string</param>\r\n  /// <param name = \"pic\">            the picture info</param>\r\n  /// <param name = \"mask\">           the mask of the string</param>\r\n  /// <param name = \"ignore_dt_fmt\"></param>\r\n  /// <returns> the magic number</returns>\r\n  a_2_date_pic_datemode(str: string[], str_len: number, pic: PIC, mask: string[], compIdx: number): number {\r\n    let pos: number = 0;\r\n    let year_in_pic: boolean = false;\r\n    let month_in_pic: boolean = false;\r\n    let day_in_pic: boolean = false;\r\n    let inp: boolean = false;\r\n    let bYearIsZero: boolean = false;\r\n    let era_year: number = 0;\r\n    let intRef: IntRef = new IntRef(0);\r\n    let intPicIdxOfs: number = 0;\r\n    let millenium: number = 0;\r\n    let dateParams: DateBreakParams;\r\n\r\n    let len: number = Math.min(str.length, pic.getMaskSize());\r\n\r\n    if (str.length < mask.length)\r\n      str.length = mask.length;\r\n\r\n    let year: number = 0;\r\n    let month: number = 1;\r\n    let day: number = 1;\r\n    let doy: number = 1;\r\n    let usedoy: boolean = false;\r\n\r\n    let i: number;\r\n    for (i = 0; i < str_len; i = i + 1) {\r\n      if (str[i] !== '0' && str[i] !== ' ') {\r\n        break;\r\n      }\r\n    }\r\n\r\n    if (i === str_len)\r\n      return 0;\r\n\r\n    while (pos < str_len && pos + intPicIdxOfs < len) {\r\n\r\n      switch (mask[pos + intPicIdxOfs].charCodeAt(0)) {\r\n        case PICInterface.PIC_YY:\r\n          year_in_pic = true;\r\n          inp = true;\r\n          year = this.date_a_2_i(str, 2, pos);\r\n          pos += 2;\r\n          // Hen 16/11/97 : Fix #768442\r\n          if (year === 0)\r\n            bYearIsZero = true;\r\n          let century_year: number = this._environment.GetCentury(compIdx) % 100; // DEF_century\r\n          if (year < century_year)\r\n            year += 100;\r\n          year += this._environment.GetCentury(compIdx) - century_year; // DEF_century\r\n          if (this._environment.GetDateMode(compIdx) === 'B')\r\n          // DEF_date_mode\r\n            year -= PICInterface.DATE_BUDDHIST_GAP;\r\n          break;\r\n\r\n\r\n        case (PICInterface.PIC_YYYY):\r\n          year_in_pic = true;\r\n          inp = true;\r\n          let YearDigitsNo: number;\r\n          // --------------------------------------------------------------\r\n          // Make sure we have 4 year digit. If not, adjust it\r\n          // according to the 'century year'\r\n          // --------------------------------------------------------------\r\n          if (UtilStrByteMode.isLocaleDefLangJPN()) {\r\n            for (YearDigitsNo = 0; YearDigitsNo < 4 && pos + YearDigitsNo < str.length && UtilStrByteMode.isDigit(str[pos + YearDigitsNo]); YearDigitsNo++) {\r\n            }\r\n            i = YearDigitsNo;\r\n          }\r\n          else {\r\n            for (i = 0; pos + i < str.length && str[pos + i] !== this.DATECHAR.toString() && i < 4; i++) {\r\n            }\r\n\r\n            for (YearDigitsNo = 0;\r\n                 pos + YearDigitsNo < str.length && UtilStrByteMode.isDigit(str[pos + YearDigitsNo]) &&\r\n                 YearDigitsNo < 4;\r\n                 YearDigitsNo++) {\r\n            }\r\n          }\r\n\r\n          if (UtilStrByteMode.isLocaleDefLangJPN()) {\r\n            if (i < 4 && str.length < mask.length)\r\n              this.move_date(str, pos, 4 - i, str.length);\r\n          }\r\n          else {\r\n            if (i < 4 && len < mask.length) {\r\n              this.move_date(str, pos, 4 - i, len);\r\n              len = len + 4 - i;\r\n            }\r\n          }\r\n\r\n          year = this.date_a_2_i(str, 4, pos);\r\n          pos += 4;\r\n\r\n          // Hen 16/11/97 : Fix #768442\r\n          if (year === 0)\r\n            bYearIsZero = true;\r\n\r\n          if (YearDigitsNo <= 2) {\r\n            century_year = this._environment.GetCentury(compIdx) % 100; // DEF_century\r\n            if (year < century_year)\r\n              year += 100;\r\n            year += this._environment.GetCentury(compIdx) - century_year; // DEF_century\r\n          }\r\n\r\n          if (this._environment.GetDateMode(compIdx) === 'B')\r\n          // DEF_date_mode\r\n            year -= PICInterface.DATE_BUDDHIST_GAP;\r\n          break;\r\n\r\n\r\n        case PICInterface.PIC_HYYYYY:\r\n          inp = true;\r\n          let quotes: number = 0;\r\n          if (len > pos + 5 && mask[pos + 5].charCodeAt(0) === (PICInterface.PIC_HYYYYY))\r\n            quotes = 1;\r\n          year = HebrewDate.dateheb_h_2_i(str, 5 + quotes, pos);\r\n          pos += 5 + quotes;\r\n          if (year === 0)\r\n            bYearIsZero = true;\r\n          break;\r\n\r\n        case PICInterface.PIC_HL:\r\n          intPicIdxOfs = HebrewDate.dateheb_h_2_i(str, 1, pos);\r\n          pos++;\r\n          break;\r\n\r\n        case PICInterface.PIC_HDD:\r\n          inp = true;\r\n          quotes = 0;\r\n          if (len > pos + 2 && mask[pos + 2].charCodeAt(0) === PICInterface.PIC_HDD)\r\n            quotes = 1;\r\n          day = HebrewDate.dateheb_h_2_i(str, 2 + quotes, pos);\r\n          pos += 2 + quotes;\r\n          break;\r\n\r\n        case PICInterface.PIC_MMD:\r\n          inp = true;\r\n          month_in_pic = true;\r\n          if (UtilStrByteMode.isLocaleDefLangJPN()) {\r\n            if ((str.length === pos + 1 || str[pos + 1].charCodeAt(0) === this.DATECHAR || !UtilStrByteMode.isDigit(str[pos + 1])) && str.length < mask.length)\r\n              this.move_date(str, pos, 1, str.length);\r\n          }\r\n          else {\r\n            if (str[pos + 1].charCodeAt(0) === this.DATECHAR && len < mask.length) {\r\n              this.move_date(str, pos, 1, len);\r\n              len += 1;\r\n            }\r\n          }\r\n          month = this.date_a_2_i(str, 2, pos);\r\n          pos += 2;\r\n          break;\r\n\r\n\r\n        case PICInterface.PIC_MMM:\r\n          inp = true;\r\n          month_in_pic = true;\r\n          intRef.val = pos;\r\n          month = this.date_MMM_2_m(str, mask, intRef, len, pic.isHebrew());\r\n          pos = intRef.val;\r\n          if (pic.isHebrew() && month === 14)\r\n            month = 6;\r\n          break;\r\n\r\n\r\n        case (PICInterface.PIC_DD):\r\n          inp = true;\r\n          day_in_pic = true;\r\n          if (UtilStrByteMode.isLocaleDefLangJPN()) {\r\n            if ((str.length === pos + 1 || str[pos + 1].charCodeAt(0) === this.DATECHAR || !UtilStrByteMode.isDigit(str[pos + 1])) && str.length < mask.length)\r\n              this.move_date(str, pos, 1, str.length);\r\n          }\r\n          else {\r\n            if (str[pos + 1].charCodeAt(0) === this.DATECHAR && len < mask.length) {\r\n              this.move_date(str, pos, 1, len);\r\n              len += 1;\r\n            }\r\n          }\r\n          day = this.date_a_2_i(str, 2, pos);\r\n          pos += 2;\r\n          break;\r\n\r\n\r\n        case (PICInterface.PIC_DDD):\r\n          inp = true;\r\n          usedoy = true;\r\n          day_in_pic = true;\r\n          doy = this.date_a_2_i(str, 3, pos);\r\n          pos += 3;\r\n          break;\r\n\r\n\r\n        case (PICInterface.PIC_DDDD):\r\n          inp = true;\r\n          day_in_pic = true;\r\n          day = this.date_a_2_i(str, 2, pos);\r\n          pos += 2 + 2;\r\n          break;\r\n\r\n\r\n        case (PICInterface.PIC_YJ): // JPN: Japanese date picture support\r\n          year_in_pic = true;\r\n          inp = true;\r\n          if (UtilStrByteMode.isLocaleDefLangJPN()) {\r\n            if ((str.length === pos + 1 || str[pos + 1].charCodeAt(0) === this.DATECHAR || !UtilStrByteMode.isDigit(str[pos + 1])) && str.length < mask.length)\r\n              this.move_date(str, pos, 1, str.length);\r\n          }\r\n          year = this.date_a_2_i(str, 2, pos);\r\n          pos += 2;\r\n\r\n          let str1: string = NString.FromChars(str);\r\n          era_year = UtilDateJpn.getInstance().getStartYearOfEra(str1, pic.getMask());\r\n\r\n          if (era_year === 0)\r\n            return 0;\r\n          year += era_year - 1;\r\n\r\n          if (year === 0)\r\n            bYearIsZero = true;\r\n          break;\r\n\r\n\r\n        default:\r\n          if (UtilStrByteMode.isLocaleDefLangDBCS()) {\r\n            // if \"str[pos]\" contains DBCS, the next index of \"mask\" has to be skipped.\r\n            if (UtilStrByteMode.isHalfWidth(str[pos]) === false &&\r\n              UtilStrByteMode.isHalfWidth(mask[pos + intPicIdxOfs]))\r\n              intPicIdxOfs++;\r\n          }\r\n\r\n          pos += 1;\r\n          break;\r\n      }\r\n    }\r\n\r\n    if (bYearIsZero) {\r\n      if (!month_in_pic)\r\n        month = 0;\r\n      if (!day_in_pic && month === 0)\r\n        day = 0;\r\n    }\r\n\r\n    // Hen 16/11/97 : Fix #768442\r\n    // Zero date is valid and should return 0L. This check must be here\r\n    // because the year value may be changed because of century year.\r\n    if (day === 0 && month === 0 && (bYearIsZero || year === 0))\r\n      return (0);\r\n\r\n    if (!inp)\r\n      return (0);\r\n\r\n    // Hebrew Year\r\n    if (pic.isHebrew()) {\r\n      if (year > 0) {\r\n        if (millenium === 0)\r\n          millenium = 5;\r\n        year += millenium * 1000;\r\n      }\r\n      return (HebrewDate.dateheb_2_d(year, month, day));\r\n    }\r\n\r\n    // the next 2 lines support 4.xx DD/MM pictures\r\n    if ((year === 0) && !year_in_pic) {\r\n      dateParams = this.date_sys();\r\n      year = dateParams.year;\r\n    }\r\n    return (this.date_4_calender(year, month, day, doy, usedoy));\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Decode digits from a date string\r\n  /// </summary>\r\n  private date_a_2_i(s: string[], len: number, pos: number): number;\r\n  private date_a_2_i(s: string, len: number, pos: number): number;\r\n  private date_a_2_i(s: any, len: number, pos: number): number {\r\n    if (arguments.length === 3 && (s === null || s instanceof Array) && (len === null || len.constructor === Number) && (pos === null || pos.constructor === Number)) {\r\n      return this.date_a_2_i_0(s, len, pos);\r\n    }\r\n    return this.date_a_2_i_1(s, len, pos);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Decode digits from a date string\r\n  /// </summary>\r\n  private date_a_2_i_0(s: string[], len: number, pos: number): number {\r\n    let array: string[] = new Array<string>(len);\r\n    let mgNum: NUM_TYPE = new NUM_TYPE();\r\n    for (let i: number = 0; i < len; i = i + 1) {\r\n      array[i] = s[pos + i];\r\n    }\r\n    return mgNum.a_2_long(NString.FromChars(array));\r\n  }\r\n\r\n  /// <summary>\r\n  ///   moving part of the date string\r\n  /// </summary>\r\n  private move_date(str: string[], pos: number, moveby: number, len: number): void;\r\n  private move_date(str: string, pos: number, moveby: number, len: number): void;\r\n  private move_date(str: any, pos: number, moveby: number, len: number): void {\r\n    if (arguments.length === 4 && (str === null || str instanceof Array) && (pos === null || pos.constructor === Number) && (moveby === null || moveby.constructor === Number) && (len === null || len.constructor === Number)) {\r\n      this.move_date_0(str, pos, moveby, len);\r\n      return;\r\n    }\r\n    this.move_date_1(str, pos, moveby, len);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   moving part of the date string\r\n  /// </summary>\r\n  private move_date_0(str: string[], pos: number, moveby: number, len: number): void {\r\n    MemoryUtil.char_memmove(str, pos + moveby, str, pos, len - (pos + moveby) + 1);\r\n    MemoryUtil.char_memset(str, pos, '0', /*'0'*/moveby);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Translate a month name -> month index\r\n  /// </summary>\r\n  /// <param name = \"string\">to evaluate\r\n  /// </param>\r\n  /// <param name = \"picture\">mask\r\n  /// </param>\r\n  /// <param name = \"pos\">current position in the string the intRef not exactly the same reference to integer , like in C++,\r\n  ///   so the global pos MUST be updated by the pos.value after the function returns.\r\n  /// </param>\r\n  private date_MMM_2_m(str: string[], mask: string[], pos: IntRef, len: number, isHebrew: boolean): number {\r\n    let l: number;\r\n\r\n    if (UtilStrByteMode.isLocaleDefLangJPN()) {\r\n      let maskPos: number = UtilStrByteMode.convPos(NString.FromChars(str), NString.FromChars(mask), pos.val, false);\r\n      l = this.date_msk_cnt(mask, maskPos, <number>(len - maskPos));\r\n    }\r\n    else {\r\n      l = this.date_msk_cnt(mask, pos.val, <number>(len - pos.val));\r\n    }\r\n    let strPos: number = pos.val;\r\n    pos.val = pos.val + l;\r\n    len = MemoryUtil.mem_trim(str, strPos, l);\r\n\r\n    if (len === 0) {\r\n      return 0;\r\n    }\r\n    else {\r\n      let strB: string = NString.FromChars(str, strPos, len);\r\n      let monthNames: string[];\r\n      if (isHebrew) {\r\n        monthNames = HebrewDate.GetLocalMonths();\r\n      }\r\n      else {\r\n        let months: string = Events.GetMessageString(MsgInterface.MONTHS_PTR);\r\n        monthNames = DateUtil.getLocalMonths(months);\r\n      }\r\n\r\n      for (let i: number = 1; i < monthNames.length; i = i + 1) {\r\n        if (NString.Compare(monthNames[i].substr(0, len), strB, true) === 0)\r\n          return i;\r\n      }\r\n    }\r\n    return 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get the curret daye seperated to year, month, day\r\n  /// </summary>\r\n  date_sys(): DateBreakParams {\r\n    let date: DateBreakParams = new DateBreakParams();\r\n    let CurrDate: DateTime = DateTime.Now;\r\n\r\n    date.year = CurrDate.Year;\r\n    date.month = CurrDate.Month;\r\n    date.day = CurrDate.Day;\r\n\r\n    return date;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   to get current date in magic representation Query Magic's Date\r\n  /// </summary>\r\n  /// <returns> the 'Magic' current date\r\n  /// </returns>\r\n  date_magic(utcDate: boolean): number {\r\n    let dateTime: DateTime;\r\n    if (utcDate) {\r\n      dateTime = DateTime.UtcNow;\r\n    }\r\n    else {\r\n      dateTime = DateTime.Now;\r\n    }\r\n\r\n    let year: number = dateTime.Year;\r\n    let month: number = dateTime.Month;\r\n    let day: number = dateTime.Day;\r\n\r\n    return this.date_4_calender(year, month, day, 1, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   to get  the system time\r\n  /// </summary>\r\n  /// <returns> the 'Magic' current time\r\n  /// </returns>\r\n  time_magic(utcTime: boolean): number {\r\n    return DateTime.GetTotalSecondsFromMidnight(utcTime, new Date());\r\n  }\r\n\r\n  mtime_magic(utcTime: boolean): number {\r\n    return DateTime.GetTotalMilliSecondsFromMidnight(utcTime, new Date()) ;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Compute MAGIC date\r\n  /// </summary>\r\n  date_4_calender(year: number, month: number, day: number, doy: number, usedoy: boolean): number {\r\n\r\n    let LeapYear: boolean = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\r\n\r\n    // 3.11.97 - Hen (Fixed bug #764265 and #8186) :\r\n    // If the date is 0 then return 0L (zero value is valid), else if the date\r\n    // is illegal then return 1000000000L (wrong date).\r\n    if (usedoy) {\r\n      if (doy === 0) {\r\n        return 0;\r\n      }\r\n      if (doy > 366 || (!LeapYear && doy > 365)) {\r\n        return (1000000000);\r\n      }\r\n    }\r\n    else {\r\n      if (day === 0 && month === 0 && year === 0) {\r\n        return 0;\r\n      }\r\n      if (day === 0 || month === 0 || year === 0 || month > 12) {\r\n        return 1000000000;\r\n      }\r\n    }\r\n    year = year - 1;\r\n    let num: number = Math.floor(year / 400);\r\n    year = year - num * 400;\r\n    let num2: number = Math.floor(year / 100);\r\n    year = year - num2 * 100;\r\n    let num3: number = Math.floor(year / 4);\r\n    year = year - num3 * 4;\r\n\r\n    if (!usedoy) {\r\n      let num4: number = PICInterface.date_day_tab[month - 1];\r\n      let num5: number = PICInterface.date_day_tab[month];\r\n\r\n      if (LeapYear) {\r\n        if (month > 1) {\r\n          num5 = num5 + 1;\r\n          if (month > 2) {\r\n            num4 = num4 + 1;\r\n          }\r\n        }\r\n      }\r\n\r\n      if (day > num5 - num4) {\r\n        return 1000000000;\r\n      }\r\n      doy = num4 + day;\r\n    }\r\n    return num * 146097 + num2 * 36524 + num3 * 1461 + year * 365 + doy;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Translates a string time to magic number\r\n  /// </summary>\r\n  /// <param name = \"dispValue\">   A string value</param>\r\n  /// <param name = \"picStr\">      The picture to use</param>\r\n  /// <returns> the magic number</returns>\r\n  fromNativeTimeToMgTime(dispValue: Date): string {\r\n    let mgNum: NUM_TYPE = new NUM_TYPE();\r\n    let numVal: number = this.fromNativeTimeToMgTimeNumber(dispValue);\r\n    mgNum.NUM_4_LONG(numVal);\r\n    return mgNum.toXMLrecord();\r\n  }\r\n\r\n  fromNativeTimeToMgTimeNumber(dispValue: Date): number {\r\n    let numVal: number = this.time_2_int(dispValue.getHours(), dispValue.getMinutes(), dispValue.getSeconds());\r\n    return numVal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Convert Alpha into a Time according to a given picture\r\n  /// </summary>\r\n  a_2_time(Ascii: string, pic: PIC, milliSeconds: boolean): number;\r\n  a_2_time(Ascii: string, AsciiL: number, mask: string[], milliSeconds: boolean): number;\r\n  a_2_time(Ascii: any, picOrAsciiL: any, milliSecondsOrMask: any, milliSeconds?: boolean): number {\r\n    if (arguments.length === 3)\r\n      return this.a_2_time_0(Ascii, picOrAsciiL, milliSecondsOrMask);\r\n\r\n    return this.a_2_time_1(Ascii, picOrAsciiL, milliSecondsOrMask, milliSeconds);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Convert Alpha into a Time according to a given picture\r\n  /// </summary>\r\n  private a_2_time_0(Ascii: string, pic: PIC, milliSeconds: boolean): number {\r\n    return this.a_2_time(Ascii, Ascii.length, NString.ToCharArray(pic.getMask()), milliSeconds);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Convert Alpha into a Time according to a given picture\r\n  /// </summary>\r\n  private a_2_time_1(Ascii: string, AsciiL: number, mask: string[], milliSeconds: boolean): number {\r\n    let mgNum: NUM_TYPE = new NUM_TYPE();\r\n    let I: number = 0;\r\n    let len: number = mask.length; // Length of mask or string to scan\r\n\r\n    // Initialize counters and flags\r\n    if (len > AsciiL) {\r\n      len = AsciiL;\r\n    }\r\n    let ampm: number = 0; // AM/PM indicator\r\n    let hour: number = 0;\r\n    let minute: number = 0;\r\n    let second: number = 0;\r\n    let millisecond: number = 0;\r\n\r\n    while (I < len) {\r\n      let maskLength: number;\r\n      let maxMaskLen: number;\r\n\r\n      // To get the maximum possible length of the constants in the mask\r\n      switch (mask[I].charCodeAt(0)) {\r\n        case (PICInterface.PIC_HH):\r\n        case (PICInterface.PIC_MMT):\r\n        case (PICInterface.PIC_SS):\r\n        case (PICInterface.PIC_PM):\r\n          maxMaskLen = 2;\r\n          break;\r\n\r\n        case (PICInterface.PIC_MS):\r\n          maxMaskLen = 3;\r\n          break;\r\n\r\n        default:\r\n          maxMaskLen = 1;\r\n          break;\r\n      }\r\n\r\n      /* To get the minimum of maxMaskLen & number of characters remained in string\r\n      because if the Ascii is shorter(has less characters)then create String only\r\n      of that no. of characters (maskLength), not of maxMaskLength */\r\n      maskLength = Math.min(maxMaskLen, len - I);\r\n\r\n      switch (mask[I].charCodeAt(0)) {\r\n        case (PICInterface.PIC_HH): {\r\n          hour = mgNum.a_2_long(Ascii.substr(I, maskLength));\r\n        }\r\n          break;\r\n\r\n        case (PICInterface.PIC_MMT): {\r\n          minute = mgNum.a_2_long(Ascii.substr(I, maskLength));\r\n        }\r\n          break;\r\n\r\n        case (PICInterface.PIC_SS): {\r\n          second = mgNum.a_2_long(Ascii.substr(I, maskLength));\r\n        }\r\n          break;\r\n\r\n        case (PICInterface.PIC_MS): {\r\n          millisecond = mgNum.a_2_long(Ascii.substr(I, maskLength));\r\n        }\r\n          break;\r\n\r\n        case (PICInterface.PIC_PM):\r\n          ampm = 0;\r\n          let c0: string = Ascii[I];\r\n          let c1: string;\r\n          c0 = c0.toUpperCase();\r\n          if (I + 1 < len) {\r\n            c1 = Ascii[I + 1];\r\n            c1 = c1.toUpperCase();\r\n\r\n            if (c1 === 'M') {\r\n              if (c0 === 'A')\r\n                ampm = -1;\r\n              if (c0 === 'P')\r\n                ampm = 1;\r\n            }\r\n          }\r\n          break;\r\n\r\n        default:\r\n          break;\r\n      }\r\n      I += maskLength;\r\n    }\r\n\r\n    // Check validity of minutes and seconds\r\n    if (second > 59 || minute > 59)\r\n      return (0);\r\n\r\n    // Convert hour to PM if specified as AM\r\n    if (ampm !== 0)\r\n      if (ampm === -1)\r\n      // AM\r\n      {\r\n        if (hour === 12)\r\n          hour = 0;\r\n      }\r\n      else if (hour < 12)\r\n      // PM\r\n        hour += 12;\r\n    if (milliSeconds)\r\n      return this.time_2_int(hour, minute, second) * 1000 + millisecond;\r\n    else\r\n      return this.time_2_int(hour, minute, second);\r\n  }\r\n\r\n  time_2_int(hour: number, minute: number, second: number): number {\r\n    return hour * 3600 + minute * 60 + second;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Convert \"0\"/\"1\" to false/true\r\n  /// </summary>\r\n  /// <param name = \"boolStr\">  \"0\"/\"1\"\r\n  /// </param>\r\n  /// <returns> true if \"1\" or false if others\r\n  /// </returns>\r\n  static toBoolean(boolStr: string): boolean {\r\n    return boolStr !== null && boolStr === \"1\";\r\n  }\r\n\r\n  /// <summary>\r\n  ///   String to Date function\r\n  /// </summary>\r\n  a_2_date(str: string, Format: string, compIdx: number): number {\r\n    return this.a_2_date_datemode(str, Format, compIdx);\r\n  }\r\n\r\n  a_2_date_pic(str: string, pic: PIC, mask: string, compIdx: number): number {\r\n    if (str === null) {\r\n      str = \"\";\r\n    }\r\n    return this.a_2_date_pic_datemode(NString.ToCharArray(str), str.length, pic, NString.ToCharArray(mask), compIdx);\r\n  }\r\n\r\n  to_a(outVal: string, out_len: number, date: number, Format: string, compIdx: number): string {\r\n    return this.to_a_datemode(outVal, out_len, date, Format, false, compIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Convert string -> date using a format string\r\n  /// </summary>\r\n  private a_2_date_datemode(str: string, Format: string, compIdx: number): number {\r\n    let pIC: PIC = new PIC(Format, StorageAttribute.DATE, compIdx);\r\n    if (str === null) {\r\n      str = \"\";\r\n    }\r\n    return this.a_2_date_pic_datemode(NString.ToCharArray(str), str.length, pIC, NString.ToCharArray(pIC.getMask()), compIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   String to a datemode\r\n  /// </summary>\r\n  private to_a_datemode(outVal: string, out_len: number, date: number, Format: string, ignore_dt_fmt: boolean, compIdx: number): string {\r\n\r\n    // Parse the picture\r\n    let pic: PIC = new PIC(Format, StorageAttribute.DATE, compIdx);\r\n\r\n    // Convert the  date -> string\r\n    if (outVal === null) {\r\n      outVal = pic.getMask();\r\n    }\r\n    return this.to_a_pic_datemode(outVal, out_len, date, pic, true, ignore_dt_fmt, compIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Decode digits from a date string\r\n  /// </summary>\r\n  private date_a_2_i_1(s: string, len: number, pos: number): number {\r\n\r\n    // don't forget to include 'pos+=len' after the using of the function\r\n    let mgNum: NUM_TYPE = new NUM_TYPE();\r\n    let str: string;\r\n\r\n    str = s.substr(pos, len);\r\n    return mgNum.a_2_long(str);\r\n  }\r\n\r\n  private move_date_1(str: string, pos: number, moveby: number, len: number): string {\r\n    str = StrUtil.memmove(str, pos + moveby, str, pos, len - pos);\r\n\r\n    str = StrUtil.memset(str, pos, '0', moveby);\r\n    return str;\r\n  }\r\n\r\n  time_2_a(Ascii: string, AsciiL: number, time: number, Format: string, compIdx: number, milliSeconds: boolean): string {\r\n\r\n    if (StrUtil.rtrim(Format).length === 0) {\r\n      Format = \"HH:MM:SS\";\r\n    }\r\n    let pic: PIC = new PIC(Format, StorageAttribute.TIME, compIdx);\r\n    if (Ascii === null) {\r\n      Ascii = pic.getMask();\r\n    }\r\n    return this.time_2_a_pic(Ascii, AsciiL, time, pic, false, milliSeconds);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Translates a string to magic logical\r\n  /// </summary>\r\n  /// <param name = \"dispValue\">   A string value\r\n  /// </param>\r\n  /// <param name = \"pic\">         The picture to use\r\n  /// </param>\r\n  /// <param name = \"rangeStr\">    The range\r\n  /// </param>\r\n  /// <returns> the logical value\r\n  /// </returns>\r\n  toLogical(dispValue: string, pic: PIC, rangeStr: string): string {\r\n    dispValue = dispValue.trim();\r\n    if (dispValue === null || dispValue.length === 0) {\r\n      dispValue = \"False\";\r\n    }\r\n    return this.disp_2_logical(dispValue, pic.getMask(), rangeStr);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   translate the displayed value to a magic logical value\r\n  /// </summary>\r\n  /// <param name = \"dispValue\">the displayed value </param>\r\n  /// <param name = \"mask\">the mask of the displayed value </param>\r\n  /// <param name = \"rangeStr\">the range string </param>\r\n  private disp_2_logical(dispValue: string, mask: string, rangeStr: string): string {\r\n\r\n    let strippedValue: StringBuilder = new StringBuilder(dispValue.length);\r\n\r\n    rangeStr = this.win_rng_bool(rangeStr);\r\n    rangeStr = StrUtil.makePrintableTokens(rangeStr, SEQ_2_HTML);\r\n    let i: number = rangeStr.indexOf(',');\r\n    let trueStr: string = rangeStr.substr(0, i);\r\n    trueStr = StrUtil.makePrintableTokens(trueStr, HTML_2_STR);\r\n    i = 0;\r\n\r\n    for (i = 0; i < dispValue.length && i < mask.length; i++) {\r\n      if (mask.charCodeAt(i) === PICInterface.PIC_X) {\r\n        strippedValue.Append(dispValue.charAt(i));\r\n      }\r\n    }\r\n    let val: string = strippedValue.ToString();\r\n    if (trueStr.length < val.length) {\r\n      val = val.substr(0, trueStr.length);\r\n    }\r\n    else {\r\n      if (val.length < trueStr.length) {\r\n        trueStr = trueStr.substr(0, val.length);\r\n      }\r\n    }\r\n    return (val.toUpperCase() === trueStr.toUpperCase()) ? \"1\" : \"0\";\r\n  }\r\n\r\n  /// <summary>\r\n  ///   converting the displayed value of a string to internal\r\n  ///   representation must remove the masking characters from it\r\n  /// </summary>\r\n  private toAlpha(dispValue: string, pic: PIC): string {\r\n\r\n    let picture: string = pic.getMask();\r\n    let buffer: StringBuilder = new StringBuilder(pic.getMaskSize());\r\n    let IsAlphaDBCS: boolean = UtilStrByteMode.isLocaleDefLangDBCS() && pic.isAttrAlpha();\r\n    let currPicture: number;\r\n    let i: number = currPicture = 0;\r\n\r\n    for (currPicture = i = 0; i < dispValue.length && currPicture < picture.length; i++, currPicture++) {\r\n      if (DisplayConvertor.isAlphaPositionalDirective(picture.charAt(currPicture))) {\r\n        buffer.Append(dispValue.charAt(i));\r\n\r\n        if (IsAlphaDBCS) {\r\n          // a DBCS character in \"dispValue\" consumes two characters in \"picture\"\r\n          let strDspValOneChar: string = dispValue.substr(i, 1);\r\n          if (UtilStrByteMode.lenB(strDspValOneChar) === 2) {\r\n            currPicture = currPicture + 1;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return buffer.ToString();\r\n  }\r\n\r\n  /// <summary>is checked char Alpha Positional Directive</summary>\r\n  static isAlphaPositionalDirective(toCheck: string): boolean {\r\n    let ascii: number = toCheck.charCodeAt(0);\r\n    return (ascii === PICInterface.PIC_X || ascii === PICInterface.PIC_U || ascii === PICInterface.PIC_L ||\r\n      ascii === PICInterface.PIC_N || ascii === PICInterface.PIC_J || ascii === PICInterface.PIC_G || ascii === PICInterface.PIC_S || ascii === PICInterface.PIC_T);\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Comparative newValue with possible Range in ContinuousRangeValues/discreteRangeValues\r\n  /// </summary>\r\n  /// <returns> newValue if it possible, old value owervise\r\n  /// </returns>\r\n  private fillAlphaByRange(ContinuousRangeValues: List<string>, discreteRangeValues: List<string>, newValue: string): string {\r\n\r\n    let tmpBuffer: string = this.fillAlphaByDiscreteRangeValues(discreteRangeValues, newValue);\r\n    if (tmpBuffer !== null) {\r\n      return tmpBuffer;\r\n    }\r\n    else {\r\n      tmpBuffer = this.fillAlphaByContinuousRangeValues(ContinuousRangeValues, newValue);\r\n      if (tmpBuffer !== null) {\r\n        return tmpBuffer;\r\n      }\r\n      else {\r\n        if (discreteRangeValues !== null) {\r\n          tmpBuffer = this.completeAlphaByRange(discreteRangeValues, newValue);\r\n          if (tmpBuffer !== null) {\r\n            return tmpBuffer;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    // unpossible to find it in the range return not changed oldvalue\r\n    return newValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   fill Alpha string by discrete range\r\n  /// </summary>\r\n  /// <param name = \"discreteRangeValues\">vector of discrete range values\r\n  /// </param>\r\n  /// <param name = \"newValue\">value, try found in the vector of discrete ranges\r\n  /// </param>\r\n  /// <returns> found value or null(not found)\r\n  /// </returns>\r\n  fillAlphaByDiscreteRangeValues(discreteRangeValues: List<string>, newValue: string): string {\r\n    if (discreteRangeValues !== null) {\r\n      for (let i: number = 0; i < discreteRangeValues.length; i = i + 1) {\r\n        let discreteValue: string = discreteRangeValues.get_Item(i);\r\n        let truncatedValue: string = discreteValue.substr(0, Math.min(newValue.length, discreteValue.length));\r\n        if (newValue.toUpperCase() === truncatedValue.toUpperCase()) {\r\n          return discreteValue;\r\n        }\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   fill Alpha string by continuous range\r\n  /// </summary>\r\n  /// <param name = \"ContinuousRangeValues\">vector of continuous range values\r\n  /// </param>\r\n  /// <param name = \"newValue\">value, try found in the vector of continuous ranges\r\n  /// </param>\r\n  /// <returns> found value or null(not found)\r\n  /// </returns>\r\n  fillAlphaByContinuousRangeValues(ContinuousRangeValues: List<string>, newValue: string): string {\r\n    newValue = StrUtil.rtrim(newValue);\r\n\r\n\r\n    if (ContinuousRangeValues !== null) {\r\n      for (let i: number = 0; i < ContinuousRangeValues.length; i = i + 1) {\r\n        let from: string = ContinuousRangeValues.get_Item(i);\r\n        let to: string = ContinuousRangeValues.get_Item(i = i + 1);\r\n        if (NString.CompareOrdinal(newValue, from) >= 0 && NString.CompareOrdinal(newValue, to) <= 0) {\r\n          return newValue;\r\n        }\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Try to complete the newValue using the Range\r\n  ///   first try to comlete the value for case meaning and after that for ignore case\r\n  /// </summary>\r\n  /// <param name = \"vector\">of ranges\r\n  /// </param>\r\n  /// <param name = \"checked\">value\r\n  /// </param>\r\n  /// <returns> value completed by range\r\n  /// </returns>\r\n  completeAlphaByRange(discreteRangeValues: List<string>, newValue: string): string {\r\n\r\n    let maxCoincide: number[] = new Array<number>(2);\r\n    for (let _ai: number = 0; _ai < maxCoincide.length; ++_ai)\r\n      maxCoincide[_ai] = 0;\r\n\r\n    let bestItem: string[] = new Array<string>(2);\r\n    for (let _ai: number = 0; _ai < bestItem.length; ++_ai)\r\n      bestItem[_ai] = null;\r\n\r\n    let CHECK_CASE: number = 0;\r\n    let IGNORE_CASE: number = 1;\r\n\r\n    let caseLetters: number = CHECK_CASE;\r\n\r\n    while (caseLetters === CHECK_CASE || caseLetters === IGNORE_CASE) {\r\n      let lowerValue: string;\r\n      if (caseLetters === CHECK_CASE) {\r\n        lowerValue = newValue;\r\n      }\r\n      else {\r\n        lowerValue = newValue.toLowerCase();\r\n      }\r\n      lowerValue = StrUtil.rtrim(lowerValue);\r\n      for (let i: number = 0; i < discreteRangeValues.length; i = i + 1) {\r\n        let wrongLetter: boolean = false;\r\n        let currCoincide: number = 0;\r\n        let rangeItem: string;\r\n        if (caseLetters === CHECK_CASE) {\r\n          rangeItem = discreteRangeValues.get_Item(i);\r\n        }\r\n        else {\r\n          rangeItem = discreteRangeValues.get_Item(i).toLowerCase();\r\n        }\r\n        let lowLength: number = lowerValue.length;\r\n        let rangeLength: number = rangeItem.length;\r\n        if (lowLength < rangeLength) {\r\n          for (let j: number = 0; j < lowLength; j = j + 1) {\r\n            if (!(lowerValue.charAt(j) === rangeItem.charAt(j))) {\r\n              wrongLetter = true;\r\n              break;\r\n            }\r\n            currCoincide = currCoincide + 1;\r\n          }\r\n        }\r\n        else {\r\n          wrongLetter = true;\r\n        }\r\n\r\n        if (currCoincide > maxCoincide[caseLetters] && !wrongLetter) {\r\n          bestItem[caseLetters] = discreteRangeValues.get_Item(i);\r\n          maxCoincide[caseLetters] = currCoincide;\r\n        }\r\n      }\r\n      caseLetters = caseLetters + 1;\r\n    }\r\n\r\n\r\n    if (bestItem[CHECK_CASE] !== null)\r\n      return bestItem[CHECK_CASE];\r\n    else {\r\n      if (bestItem[IGNORE_CASE] !== null)\r\n        return bestItem[IGNORE_CASE];\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  setDateChar(dateChar: number): void {\r\n    this.DATECHAR = dateChar;\r\n  }\r\n\r\n  getDateChar(): number {\r\n    return this.DATECHAR;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"value\"></param>\r\n  /// <param name=\"storageAttribute\"></param>\r\n  /// <returns></returns>\r\n  static StringValueToMgValue(value: string, storageAttribute: StorageAttribute, filler: string, length: number): any {\r\n    switch (storageAttribute) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE: {\r\n        let newVal: string = value;\r\n        newVal = NString.PadRight(newVal, length, filler);\r\n        return newVal;\r\n      }\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        return new NUM_TYPE(value);\r\n      default:\r\n        return value;\r\n    }\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   Being used to send parameters to the 'time_break' method\r\n/// </summary>\r\nexport class TimeBreakParams {\r\n  hour: number = 0;\r\n  minute: number = 0;\r\n  second: number = 0;\r\n\r\n  constructor();\r\n  constructor(hour_: number, minute_: number, second_: number);\r\n  constructor(hour_?: number, minute_?: number, second_?: number) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    this.constructor_1(hour_, minute_, second_);\r\n  }\r\n\r\n  private constructor_0(): void {\r\n  }\r\n\r\n  private constructor_1(hour_: number, minute_: number, second_: number): void {\r\n    this.hour = hour_;\r\n    this.minute = minute_;\r\n    this.second = second_;\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   Being used to send int by Ref\r\n/// </summary>\r\nclass IntRef {\r\n  val: number = 0;\r\n\r\n  constructor(val_: number) {\r\n    this.val = val_;\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   Being used to send parameters to the 'date_i_2_nm' method\r\n/// </summary>\r\nclass DateNameParams {\r\n  outVal: string[] = null;\r\n  len: number = 0;\r\n  outIdx: number = 0;\r\n\r\n  constructor(out_: string[], outIdx_: number, len_: number) {\r\n    this.outVal = out_;\r\n    this.outIdx = outIdx_;\r\n    this.len = len_;\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   Being used to send parameters to the 'date_break_datemode' method\r\n///   it's struct\r\n/// </summary>\r\nexport class DateBreakParams {\r\n  day: number = 0;\r\n  dow: number = 0;\r\n  doy: number = 0;\r\n  month: number = 0;\r\n  year: number = 0;\r\n\r\n  constructor();\r\n  constructor(year_: number, month_: number, day_: number, doy_: number, dow_: number);\r\n  constructor(year_?: number, month_?: number, day_?: number, doy_?: number, dow_?: number) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    this.constructor_1(year_, month_, day_, doy_, dow_);\r\n  }\r\n\r\n  private constructor_0(): void {\r\n  }\r\n\r\n  private constructor_1(year_: number, month_: number, day_: number, doy_: number, dow_: number): void {\r\n    this.year = year_;\r\n    this.month = month_;\r\n    this.day = day_;\r\n    this.doy = doy_;\r\n    this.dow = dow_;\r\n  }\r\n}\r\n"]}