@magic-xpa/gui 4.800.0 → 4.801.0-dev000.0

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

@@ -0,0 +1,1507 @@
+import { DateTime, Exception, NChar, NNumber, NString, NumberFormatInfo, StringBuilder } from '@magic-xpa/mscorelib';
+import { DisplayConvertor } from './DisplayConvertor';
+import { DateUtil, HTML_2_STR, MgControlType, MsgInterface, PICInterface, StorageAttribute, StrUtil, UtilDateJpn, UtilStrByteMode } from '@magic-xpa/utils';
+import { Events } from '../../Events';
+import { WrongFormatException } from './WrongFormatException';
+import { DateElement } from '../../GuiEnums';
+import { NUM_TYPE } from '../data/NUM_TYPE';
+import { HebrewDate } from './HebrewDate';
+import { BlobType } from '../data/BlobType';
+import { GuiEnvironment } from '../../GuiEnvironment';
+import { PropInterface } from "./PropInterface";
+export class FieldValidator {
+    constructor() {
+        this._newvalue = null;
+        this._oldvalue = null;
+        this._pictureReal = null;
+        this._pictureEnable = null;
+        this._valDet = null;
+        this._isPm = false;
+        this._picture = null;
+        this.hebrew = false;
+        this._decimal = null;
+        this._environment = null;
+        this._environment = GuiEnvironment.Environment;
+        this._decimal = (this._environment.GetDecimal() || "");
+    }
+    checkVal(valDet) {
+        this._newvalue = (this._oldvalue = (this._pictureReal = (this._pictureEnable = null)));
+        this.init(valDet);
+        valDet.setValidationFailed(false);
+        let ctrl = valDet.getControl();
+        let modInQueuy = ctrl.isRepeatable() ? false : ctrl.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MODIFY_IN_QUERY, false, ctrl.getDisplayLine(false));
+        let useNative = ctrl.isModifiable();
+        if (ctrl.getForm().getTask().getMode() === 'E' && !modInQueuy) {
+            valDet.setValue(this._oldvalue);
+            return valDet;
+        }
+        if (ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_TAB || ctrl.isSelectionCtrl()) {
+            try {
+                if (ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX) {
+                    valDet.setNull(ctrl.isNullValue(this._newvalue));
+                }
+                if (this._newvalue !== null && ctrl.isSelectionCtrl()) {
+                    let idx = NNumber.Parse(this._newvalue);
+                    if (ctrl.isChoiceNull(idx)) {
+                        valDet.setNull(true);
+                    }
+                }
+            }
+            catch (ex_111) {
+                if (ex_111 instanceof Exception) {
+                }
+                else
+                    throw ex_111;
+            }
+            valDet.setValue(this._newvalue);
+            return valDet;
+        }
+        if (ctrl.DataType !== StorageAttribute.ALPHA && ctrl.DataType !== StorageAttribute.UNICODE && ctrl.DataType !== StorageAttribute.BLOB) {
+            if ((typeof this._newvalue === 'string' && this._newvalue.trim().length === 0) || (ctrl.DataType === StorageAttribute.DATE && (ctrl.isDateZero(this._newvalue) || this.isNullDisplayVal()))) {
+                let field = ctrl.getField();
+                let defaultValue = field.getDefaultValue();
+                let text = null;
+                if (field.isNullDefault()) {
+                    valDet.setNull(true);
+                    text = field.getNullDisplay();
+                    if (NString.IsNullOrEmpty(text) && ctrl.DataType === StorageAttribute.DATE) {
+                        text = DisplayConvertor.Instance.mg2disp(defaultValue, valDet.getRange(), valDet.getPIC(), useNative, field.getTask().getCompIdx(), false);
+                    }
+                }
+                if (text === null) {
+                    text = DisplayConvertor.Instance.mg2disp(defaultValue, valDet.getRange(), valDet.getPIC(), useNative, field.getTask().getCompIdx(), false);
+                }
+                if ((!field.isNullDefault() && (this._valDet.getContinuousRangeValues() !== null || this._valDet.getDiscreteRangeValues() !== null)))
+                    this._newvalue = text;
+                else {
+                    valDet.setValue(text);
+                    return valDet;
+                }
+            }
+        }
+        if ((typeof this._newvalue === 'string' && !(StrUtil.rtrim(this._newvalue) === StrUtil.rtrim(this._oldvalue))) || ctrl.ModifiedByUser) {
+            try {
+                switch (valDet.getType()) {
+                    case StorageAttribute.ALPHA:
+                    case StorageAttribute.UNICODE:
+                        valDet.setValue(this.checkAlphaField());
+                        break;
+                    case StorageAttribute.NUMERIC:
+                        this._pictureReal = valDet.getPictureReal();
+                        this._pictureEnable = valDet.getPictureEnable();
+                        this.checkNumericPicture();
+                        valDet.setValue(this.checkNumericField());
+                        break;
+                    case StorageAttribute.BOOLEAN:
+                        valDet.setValue(this.checkLogicalField());
+                        break;
+                    case StorageAttribute.DATE:
+                        valDet.setValue(this.checkDateField());
+                        break;
+                    case StorageAttribute.TIME:
+                        valDet.setValue(this.checkTimeField());
+                        break;
+                    case StorageAttribute.BLOB:
+                    case StorageAttribute.BLOB_VECTOR:
+                        valDet.setValue(this._newvalue);
+                        break;
+                    case StorageAttribute.NONE:
+                    default:
+                        Events.WriteExceptionToLog("FieldValidator.checkVal: Type of the field " + valDet.getType());
+                        break;
+                }
+            }
+            catch (goBack) {
+                if (goBack instanceof WrongFormatException) {
+                    valDet.setValue(this._oldvalue);
+                    this.setValidationFailed(true);
+                    if (goBack.getType() !== MsgInterface.STR_RNG_TXT) {
+                        this.printMessage(goBack.getType(), false);
+                        this.setValidationFailed(true);
+                    }
+                    else
+                        this.printMessage(MsgInterface.STR_RNG_TXT, true);
+                }
+            }
+        }
+        return valDet;
+    }
+    checkAlphaField() {
+        let control = this._valDet.getControl();
+        let IsAttrAlpha = this._valDet.getType() === StorageAttribute.ALPHA;
+        if (this._newvalue.length === 0 && this._valDet.getContinuousRangeValues() === null && this._valDet.getDiscreteRangeValues() === null) {
+            this.setValidationFailed(false);
+            return this._newvalue;
+        }
+        if (IsAttrAlpha && UtilStrByteMode.isLocaleDefLangDBCS()) {
+            let picLenB = UtilStrByteMode.lenB(this._picture);
+            if (UtilStrByteMode.lenB(this._newvalue) > picLenB) {
+                this._newvalue = UtilStrByteMode.leftB(this._newvalue, picLenB);
+            }
+        }
+        else {
+            if (this._newvalue.length > this._picture.length) {
+                this._newvalue = this._newvalue.substr(0, this._picture.length);
+            }
+        }
+        let stringBuilder = new StringBuilder();
+        let currPicture;
+        let i = currPicture = 0;
+        for (currPicture = i = 0; i < this._newvalue.length && currPicture < this._picture.length;) {
+            if (!DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture)) && this._newvalue.charAt(i) === this._picture.charAt(currPicture)) {
+                stringBuilder.Append(this._picture.charAt(currPicture));
+                i = i + 1;
+                currPicture = currPicture + 1;
+            }
+            else {
+                if (!DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture)) && this._newvalue.charAt(i) !== this._picture.charAt(currPicture)) {
+                    stringBuilder.Append(this._picture.charAt(currPicture));
+                    currPicture = currPicture + 1;
+                }
+                else {
+                    if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture)) && this.isPossibleAlphaLetter(i, currPicture)) {
+                        if (UtilStrByteMode.isLocaleDefLangDBCS()) {
+                            let strVal = this._newvalue.substr(i, 1);
+                            if (UtilStrByteMode.lenB(strVal) === 2) {
+                                if (IsAttrAlpha) {
+                                    if (currPicture + 1 < this._picture.length) {
+                                        if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture + 1)) && this.isPossibleAlphaLetter(i, currPicture + 1)) {
+                                            stringBuilder.Append(this._newvalue.charAt(i));
+                                            i = i + 1;
+                                            currPicture = currPicture + 2;
+                                        }
+                                        else {
+                                            stringBuilder.Append(' ');
+                                            currPicture = currPicture + 1;
+                                        }
+                                    }
+                                    else {
+                                        stringBuilder.Append(' ');
+                                        currPicture = currPicture + 1;
+                                    }
+                                }
+                                else {
+                                    stringBuilder.Append(this._newvalue.charAt(i));
+                                    i = i + 1;
+                                    currPicture = currPicture + 1;
+                                }
+                            }
+                            else {
+                                stringBuilder.Append(this._newvalue.charAt(i));
+                                i = i + 1;
+                                currPicture = currPicture + 1;
+                            }
+                        }
+                        else {
+                            stringBuilder.Append(this._newvalue.charAt(i));
+                            i = i + 1;
+                            currPicture = currPicture + 1;
+                        }
+                    }
+                    else {
+                        stringBuilder.Append(' ');
+                        currPicture = currPicture + 1;
+                        if (this._valDet.getControl() !== null) {
+                            let type = control.Type;
+                            if (type !== MgControlType.CTRL_TYPE_BUTTON) {
+                                this.printMessage(MsgInterface.STR_ERR_NUM, false);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        this._newvalue = stringBuilder.ToString();
+        if (this._valDet.getContinuousRangeValues() !== null || this._valDet.getDiscreteRangeValues() !== null) {
+            this._newvalue = this.fillAlphaByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues());
+        }
+        return this._newvalue;
+    }
+    isPossibleAlphaLetter(indexInput, indexPicture) {
+        let result;
+        switch (this._picture.charCodeAt(indexPicture)) {
+            case PICInterface.PIC_X:
+            case PICInterface.PIC_J:
+            case PICInterface.PIC_G:
+            case PICInterface.PIC_S:
+            case PICInterface.PIC_T:
+                return true;
+            case PICInterface.PIC_U:
+                let upper = this._newvalue[indexInput].toUpperCase();
+                if (upper !== this._newvalue[indexInput])
+                    this.changeStringInside("" + upper, indexInput);
+                return true;
+            case PICInterface.PIC_L:
+                let lower = this._newvalue[indexInput].toLowerCase();
+                if (lower !== this._newvalue[indexInput])
+                    this.changeStringInside("" + lower, indexInput);
+                return true;
+            case PICInterface.PIC_N:
+                let number1 = this._newvalue[indexInput];
+                if (UtilStrByteMode.isDigit(number1) || NChar.IsWhiteSpace(number1) || UtilStrByteMode.asNumeric(number1))
+                    return true;
+                else {
+                    Events.WriteErrorToLog("Bad Alpha value. Should be number only on place Num. " + indexInput);
+                    return false;
+                }
+            default:
+                Events.WriteErrorToLog("FieldValidator.isPossibleAlphaLetter: illegal Char Directive: " + this._picture.indexOf(String.fromCharCode(indexPicture)) + " for " + this._newvalue[indexInput]);
+                return false;
+        }
+    }
+    fillAllAlpha() {
+        let stringBuilder = new StringBuilder(this._picture.length);
+        stringBuilder.Append(this._newvalue);
+        if (UtilStrByteMode.isLocaleDefLangDBCS() && this._valDet.getType() === StorageAttribute.ALPHA) {
+            let intNewvalueLenB = UtilStrByteMode.lenB(this._newvalue);
+            let strBuiedPicture = UtilStrByteMode.leftB(this._picture, intNewvalueLenB);
+            for (let i = strBuiedPicture.length; i < this._picture.length; i = i + 1) {
+                if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(i))) {
+                    stringBuilder.Append(' ');
+                }
+                else {
+                    stringBuilder.Append(this._picture.charAt(i));
+                }
+            }
+        }
+        else {
+            for (let i = this._newvalue.length - 1; i < this._picture.length && i >= 0; i++) {
+                if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(i))) {
+                    stringBuilder.Append(' ');
+                }
+                else {
+                    stringBuilder.Append(this._picture.charAt(i));
+                }
+                i = i + 1;
+            }
+        }
+        return stringBuilder.ToString();
+    }
+    fillAlphaByRange(ContinuousRangeValues, DiscreteRangeValues) {
+        let tmpBuffer = DisplayConvertor.Instance.fillAlphaByDiscreteRangeValues(DiscreteRangeValues, this._newvalue);
+        if (tmpBuffer !== null) {
+            return tmpBuffer;
+        }
+        tmpBuffer = DisplayConvertor.Instance.fillAlphaByContinuousRangeValues(ContinuousRangeValues, this._newvalue);
+        if (tmpBuffer !== null)
+            return tmpBuffer;
+        if (DiscreteRangeValues !== null)
+            return this.CompleteAlphaByRange(DiscreteRangeValues);
+        this.printMessage(MsgInterface.STR_RNG_TXT, true);
+        return this._oldvalue;
+    }
+    CompleteAlphaByRange(DiscreteRangeValues) {
+        let tmpNewValue = DisplayConvertor.Instance.completeAlphaByRange(DiscreteRangeValues, this._newvalue);
+        if (tmpNewValue !== null) {
+            return tmpNewValue;
+        }
+        this.printMessage(MsgInterface.STR_RNG_TXT, true);
+        return this._oldvalue;
+    }
+    checkLogicalField() {
+        if (this._newvalue.length === 0 && this._valDet.getContinuousRangeValues() === null && this._valDet.getDiscreteRangeValues() === null) {
+            throw new WrongFormatException(MsgInterface.STR_RNG_TXT);
+        }
+        if (this._valDet.getContinuousRangeValues() !== null || this._valDet.getDiscreteRangeValues() !== null) {
+            this._newvalue = this.fillAlphaByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues());
+        }
+        this.setValidationFailed(false);
+        return this._newvalue;
+    }
+    checkNumericField() {
+        let evaluated;
+        if (typeof this._newvalue === 'string') {
+            if (this._newvalue.length === 0) {
+                this._newvalue = "0";
+            }
+            let delimeterRealIndex = this._newvalue.indexOf(this._decimal);
+            let delimeterPictIndex = this._pictureReal.indexOf(this._decimal);
+            evaluated = "";
+            let evaluatedLeft;
+            let evaluatedRight;
+            this.setValidationFailed(false);
+            if (!this.checkNumericInDecFormat())
+                throw new WrongFormatException(MsgInterface.EDT_ERR_STR_1);
+            if (delimeterPictIndex !== -1 && delimeterRealIndex !== -1) {
+                evaluatedLeft = this.checkNumericLeft(delimeterPictIndex, delimeterRealIndex);
+                evaluatedRight = this.checkNumericRight(delimeterPictIndex, delimeterRealIndex);
+                evaluated = evaluatedLeft + this._decimal + evaluatedRight;
+            }
+            else {
+                if (delimeterPictIndex !== -1 && delimeterRealIndex === -1) {
+                    evaluatedLeft = this.checkNumericLeft(delimeterPictIndex, Math.min(delimeterPictIndex, this._newvalue.length));
+                    evaluatedRight = this.checkNumericRight(delimeterPictIndex, delimeterPictIndex - 1);
+                    evaluated = evaluatedLeft + this._decimal + evaluatedRight;
+                }
+                else {
+                    if (delimeterPictIndex === -1 && delimeterRealIndex === -1) {
+                        evaluated = this.checkNumericRight(-1, -1);
+                        evaluatedLeft = evaluated;
+                    }
+                    else {
+                        if (delimeterRealIndex > 0) {
+                            this._newvalue = this._newvalue.substr(0, delimeterRealIndex);
+                        }
+                        else {
+                            this._newvalue = "0";
+                        }
+                        evaluated = this.checkNumericRight(-1, -1);
+                        evaluatedLeft = evaluated;
+                    }
+                }
+            }
+            if ((evaluatedRight.length === 0 && evaluatedLeft.length === 0) || (evaluated.length === 0 && this._newvalue.length > 0)) {
+                let ctrl;
+                ctrl = this._valDet.getControl();
+                let field = ctrl.getField();
+                let defValue = field.getDefaultValue();
+                let dispDefValue = null;
+                if (field.isNullDefault()) {
+                    this._valDet.setNull(true);
+                    dispDefValue = field.getNullDisplay();
+                }
+                if (dispDefValue == null)
+                    dispDefValue = DisplayConvertor.Instance.mg2disp(defValue, this._valDet.getRange(), this._valDet.getPIC(), true, field.getTask().getCompIdx(), false);
+            }
+            let wholeDigitdiff = this.digitsBeforeDelimeter(evaluated, 0, this._decimal) - this._valDet.getPIC().getWholes();
+            if (wholeDigitdiff > 0) {
+                let padCharOnly = false;
+                if (this._valDet.getIsPadFill()) {
+                    padCharOnly = true;
+                    for (let i = 0; i < wholeDigitdiff && padCharOnly; i++)
+                        if (evaluated[i] !== this._valDet.getPadFillChar())
+                            padCharOnly = false;
+                }
+                if (!padCharOnly)
+                    throw new WrongFormatException(MsgInterface.EDT_ERR_STR_1);
+            }
+            if (this._valDet.getIsNegative() && (this._newvalue.trim().startsWith("-") || (this._valDet.getNegativeSignPref().length !== 0 && this._newvalue.trim().startsWith(this._valDet.getNegativeSignPref())))) {
+                evaluated = "-" + evaluated;
+            }
+            evaluated = DisplayConvertor.Instance.disp2mg(this._newvalue, this._valDet.getPIC(), this._valDet.getControl().getForm().getTask().getCompIdx(), BlobType.CONTENT_TYPE_UNKNOWN);
+            evaluated = DisplayConvertor.Instance.mg2disp(evaluated, "", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), true);
+            let tempDispVal = StrUtil.ltrim(evaluated);
+            if (tempDispVal.length === 0 && this._valDet.getPIC().zeroFill() && this._valDet.getPIC().getZeroPad() === ' ')
+                evaluated = "0";
+        }
+        else {
+            evaluated = DisplayConvertor.Instance.disp2mg(this._newvalue, this._valDet.getPIC(), this._valDet.getControl().getForm().getTask().getCompIdx(), BlobType.CONTENT_TYPE_UNKNOWN);
+            evaluated = DisplayConvertor.Instance.mg2disp(evaluated, "", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), true);
+        }
+        if (this._valDet.getContinuousRangeValues() != null || this._valDet.getDiscreteRangeValues() != null) {
+            this._newvalue = evaluated;
+            evaluated = this.fillNumericByRange();
+        }
+        return evaluated;
+    }
+    checkNumericLeft(delimeterPictIndex, delimeterRealIndex) {
+        let buffer = new StringBuilder();
+        let RealIndex = delimeterRealIndex - 1;
+        let PictIndex;
+        let isFound;
+        for (PictIndex = delimeterPictIndex - 1; PictIndex >= 0 && RealIndex >= 0; PictIndex--) {
+            if (this._pictureEnable[PictIndex] === '1') {
+                let tmpstorage = RealIndex;
+                isFound = false;
+                for (; RealIndex >= 0; RealIndex--) {
+                    if (this._pictureReal[PictIndex] === this._newvalue[RealIndex]) {
+                        isFound = true;
+                        RealIndex--;
+                        break;
+                    }
+                }
+                if (!isFound)
+                    RealIndex = tmpstorage;
+                buffer.Append(this._pictureReal[PictIndex]);
+            }
+            else {
+                for (; RealIndex >= 0; RealIndex--) {
+                    if (UtilStrByteMode.isDigit(this._newvalue[RealIndex])) {
+                        buffer.Append(this._newvalue[RealIndex]);
+                        RealIndex--;
+                        break;
+                    }
+                }
+            }
+        }
+        if (RealIndex < 0 && PictIndex >= 0)
+            for (; PictIndex >= 0; PictIndex--) {
+                if (this._pictureEnable[PictIndex] === '1')
+                    buffer.Append(this._pictureReal[PictIndex]);
+                else {
+                    if (this._valDet.getIsPadFill())
+                        buffer.Append(this._valDet.getPadFillChar());
+                }
+            }
+        return StrUtil.ReverseString(buffer).ToString();
+    }
+    checkNumericRight(delimeterPictIndex, delimeterRealIndex) {
+        let buffer = new StringBuilder();
+        let RealIndex = delimeterRealIndex + 1;
+        let PictIndex;
+        let pic = this._valDet.getPIC();
+        for (PictIndex = delimeterPictIndex + 1; PictIndex < this._pictureEnable.length && RealIndex < this._newvalue.length; PictIndex++) {
+            if (this._pictureEnable[PictIndex] === '1') {
+                if (RealIndex < PictIndex)
+                    RealIndex = PictIndex;
+                buffer.Append(this._pictureReal[PictIndex]);
+            }
+            else {
+                for (; RealIndex < this._newvalue.length; RealIndex++) {
+                    if (UtilStrByteMode.isDigit(this._newvalue[RealIndex]) && !pic.picIsMask(RealIndex)) {
+                        buffer.Append(this._newvalue[RealIndex]);
+                        RealIndex++;
+                        break;
+                    }
+                }
+            }
+        }
+        if (buffer.Length > 0) {
+            if (RealIndex >= this._newvalue.length && PictIndex < this._pictureReal.length)
+                for (; PictIndex < this._pictureReal.length; PictIndex++) {
+                    if (this._pictureEnable[PictIndex] === '1')
+                        buffer.Append(this._pictureReal[PictIndex]);
+                }
+        }
+        return buffer.ToString();
+    }
+    checkNumericPicture() {
+        let indexOfDec;
+        let lastDec;
+        let maxLength;
+        let currIndx;
+        let POINT_DEC = ".";
+        let pic = this._valDet.getPIC();
+        if (this._pictureReal == null || this._pictureEnable == null || pic.getAttr() !== StorageAttribute.NUMERIC || !pic.withDecimal())
+            return;
+        lastDec = this._pictureReal.lastIndexOf(POINT_DEC);
+        maxLength = this._pictureEnable.length;
+        currIndx = 0;
+        while (currIndx < lastDec) {
+            indexOfDec = this._pictureEnable.indexOf("1", currIndx);
+            if (indexOfDec === -1)
+                return;
+            else {
+                if (indexOfDec === this._pictureReal.indexOf(POINT_DEC, currIndx)) {
+                    let first;
+                    let second;
+                    first = second = "";
+                    if (indexOfDec === 0) {
+                        if (indexOfDec + 1 < maxLength)
+                            second = this._pictureReal.substr(indexOfDec + 1);
+                    }
+                    else if (indexOfDec === maxLength) {
+                        first = this._pictureReal.substr(0, indexOfDec);
+                    }
+                    else {
+                        first = this._pictureReal.substr(0, indexOfDec);
+                        second = this._pictureReal.substr(indexOfDec + 1);
+                    }
+                    this._pictureReal = first + this._decimal + second;
+                    break;
+                }
+                else {
+                    currIndx = ++indexOfDec;
+                }
+            }
+        }
+    }
+    fillNumericByRange() {
+        let controlPic = this._valDet.getControl().getPIC();
+        let continuousRangeValues = this._valDet.getContinuousRangeValues();
+        let discreteRangeValues = this._valDet.getDiscreteRangeValues();
+        this.setValidationFailed(false);
+        let checkedStr = this.setNumericValueWithoutPicture(this._newvalue.toString());
+        if (checkedStr.length === 0) {
+            this.printMessage(MsgInterface.STR_RNG_TXT, true);
+            return this._oldvalue;
+        }
+        let checkedNum = new NUM_TYPE(this._newvalue.toString(), this._valDet.getControl().getPIC(), 0);
+        if (discreteRangeValues !== null) {
+            for (let i = 0; i < discreteRangeValues.length; i = i + 1) {
+                let rangeItemValue1 = new NUM_TYPE(discreteRangeValues.get_Item(i), controlPic, 0);
+                try {
+                    if (NUM_TYPE.num_cmp(checkedNum, rangeItemValue1) === 0) {
+                        return this._newvalue;
+                    }
+                }
+                catch (ex_CC) {
+                }
+            }
+        }
+        if (continuousRangeValues !== null) {
+            for (let i = 0; i < continuousRangeValues.length; i = i + 1) {
+                let rangeItemValue1 = new NUM_TYPE();
+                let rangeItemValue2 = new NUM_TYPE();
+                rangeItemValue1.num_4_a_std(continuousRangeValues.get_Item(i++));
+                rangeItemValue2.num_4_a_std(continuousRangeValues.get_Item(i));
+                try {
+                    if (NUM_TYPE.num_cmp(checkedNum, rangeItemValue1) !== -1 && NUM_TYPE.num_cmp(rangeItemValue2, checkedNum) !== -1) {
+                        return this._newvalue;
+                    }
+                }
+                catch (ex_15B) {
+                }
+            }
+        }
+        throw new WrongFormatException();
+    }
+    getDoubleVal(val) {
+        let dotFound = false;
+        let minusFound = false;
+        let digitFound = false;
+        let endOfNum = false;
+        let i = 0;
+        for (i = 0; i < val.length && !endOfNum; i++) {
+            let c = val[i];
+            if (c >= '0' && c <= '9')
+                digitFound = true;
+            else {
+                switch (c) {
+                    case '-':
+                        if (digitFound || dotFound || minusFound)
+                            endOfNum = true;
+                        minusFound = true;
+                        break;
+                    case '.':
+                        if (dotFound || minusFound && !digitFound)
+                            endOfNum = true;
+                        dotFound = true;
+                        break;
+                    case ' ':
+                        if (digitFound || dotFound || minusFound)
+                            endOfNum = true;
+                        break;
+                    default:
+                        endOfNum = true;
+                        break;
+                }
+            }
+        }
+        if (endOfNum) {
+            i = i - 1;
+        }
+        if (i > 0) {
+            return NNumber.Parse(val.substr(0, i));
+        }
+        return -Infinity;
+    }
+    setNumericValueWithoutPicture(val) {
+        let checkedStr = new StringBuilder(val.length);
+        let isFirstDecimal = false;
+        let currChar;
+        for (let i = 0; i < this._pictureReal.length && i < val.length; i++) {
+            currChar = val[i];
+            if (UtilStrByteMode.isDigit(currChar))
+                checkedStr.Append(currChar);
+            else if (currChar === this._environment.GetDecimal() && !isFirstDecimal) {
+                checkedStr.Append(NString.ToCharArray(NumberFormatInfo.NumberDecimalSeparator).toString());
+                isFirstDecimal = true;
+            }
+            else if (currChar === '-' && this._valDet.getIsNegative())
+                checkedStr.Append(NString.ToCharArray(NumberFormatInfo.NegativeSign).toString());
+        }
+        if (checkedStr.ToString().length === 0) {
+            this.printMessage(MsgInterface.STR_ERR_NUM, false);
+            this.setValidationFailed(true);
+        }
+        return checkedStr.ToString();
+    }
+    checkNumericInDecFormat() {
+        let pic = this._valDet.getPIC();
+        let i;
+        let Dec;
+        let Whole;
+        let DecPos;
+        let decimalChar = this._environment.GetDecimal();
+        Dec = 0;
+        Whole = 0;
+        DecPos = -1;
+        for (i = 0; i < this._newvalue.length; i++)
+            if (pic.isNumeric(i))
+                if (UtilStrByteMode.isDigit(this._newvalue[i]))
+                    if (DecPos >= 0)
+                        Dec++;
+                    else
+                        Whole++;
+                else if (this._newvalue[i] === decimalChar)
+                    DecPos = i;
+        if (pic.getWholes() < Whole || pic.getDec() < Dec)
+            return false;
+        else
+            return true;
+    }
+    checkDateField() {
+        let newDate = (this._newvalue == null ? null : new Date(this._newvalue));
+        this.setValidationFailed(false);
+        if (this._valDet.getControl().isDateZero(this._newvalue)) {
+            let defaultMgValue = this._valDet.getControl().getField().getDefaultValue();
+            newDate = DisplayConvertor.Instance.mg2disp(defaultMgValue, "", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), false);
+        }
+        else {
+            if (this._valDet.getContinuousRangeValues() != null || this._valDet.getDiscreteRangeValues() != null)
+                newDate = this.fillDateByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues(), this._newvalue);
+        }
+        return newDate;
+    }
+    add2Date(currValue, buffer, type) {
+        let start = currValue;
+        let currAdd = new StringBuilder(this._newvalue.length);
+        let letters = 0;
+        switch (type) {
+            case PICInterface.PIC_DD:
+            case PICInterface.PIC_DDDD:
+            case PICInterface.PIC_MMD:
+            case PICInterface.PIC_YY:
+                letters = 2;
+                break;
+            case PICInterface.PIC_DDD:
+                letters = 3;
+                break;
+            case PICInterface.PIC_YYYY:
+                letters = 4;
+                break;
+            case PICInterface.PIC_W:
+                letters = 1;
+                break;
+            case PICInterface.PIC_YJ:
+                letters = 2;
+                type = PICInterface.PIC_YY;
+                break;
+        }
+        while (start < this._newvalue.length && !UtilStrByteMode.isDigit(this._newvalue.charAt(start)))
+            start++;
+        if (start === this._newvalue.length && (this._newvalue.length === 0 || this._newvalue === "0")) {
+            for (let nul = 0; nul < letters; nul = nul + 1) {
+                buffer.Append('0');
+            }
+            return currValue;
+        }
+        else if (start === this._newvalue.length) {
+            this._newvalue = this._newvalue + "0";
+        }
+        let i;
+        for (i = start; i < start + letters && i < this._newvalue.length; i++) {
+            if (UtilStrByteMode.isDigit(this._newvalue.charAt(i)))
+                currAdd.Append(this._newvalue.charAt(i));
+            else
+                break;
+        }
+        if (currAdd.Length === 0) {
+            currAdd.Append('0');
+        }
+        let add = NNumber.Parse(currAdd.ToString());
+        if ((add < 1 && type !== PICInterface.PIC_YYYY && type !== PICInterface.PIC_YY) ||
+            (add > 31 && (type === PICInterface.PIC_DD || type === PICInterface.PIC_DDDD)) ||
+            (add > 12 && type === PICInterface.PIC_MMD) || (add > 7 && type === PICInterface.PIC_W)) {
+            throw new WrongFormatException(MsgInterface.STR_ERR_DATE);
+        }
+        if (type === PICInterface.PIC_YYYY && this._environment.GetCentury(this._valDet.getControl().getForm().getTask().getCompIdx()) > 999 && currAdd.Length < 3)
+            currAdd = this.checkCentury(add);
+        for (let j = 0; j < letters - currAdd.Length; j = j + 1) {
+            buffer.Append('0');
+        }
+        buffer.Append(currAdd.ToString());
+        return i;
+    }
+    addM2Date(currValue, letters, buffer, type) {
+        let array;
+        let result;
+        if (type === PICInterface.PIC_MMM || type === PICInterface.PIC_MMD) {
+            if (this.hebrew) {
+                array = HebrewDate.GetLocalMonths();
+            }
+            else {
+                let messageString = Events.GetMessageString(MsgInterface.MONTHS_PTR);
+                array = DateUtil.getLocalMonths(messageString);
+            }
+        }
+        else {
+            if (type === PICInterface.PIC_WWW || type === PICInterface.PIC_W) {
+                if (this.hebrew) {
+                    array = HebrewDate.GetLocalDows();
+                }
+                else {
+                    let dayStr = Events.GetMessageString(MsgInterface.DAYS_PTR);
+                    array = DateUtil.getLocalDays(dayStr);
+                }
+            }
+            else {
+                if (type === PICInterface.PIC_BB) {
+                    array = UtilDateJpn.getArrayDow();
+                }
+                else {
+                    if (type === PICInterface.PIC_JY1 || type === PICInterface.PIC_JY2 || type === PICInterface.PIC_JY4) {
+                        if (this._newvalue.length < currValue + letters) {
+                            throw new WrongFormatException(MsgInterface.STR_ERR_DATE);
+                        }
+                        let text = this._newvalue.substr(currValue, letters);
+                        buffer.Append(text);
+                        return currValue + text.length;
+                    }
+                    else {
+                        return currValue + letters;
+                    }
+                }
+            }
+        }
+        if (this._newvalue.length < currValue) {
+            currValue = this._newvalue.length;
+        }
+        let max = this.getMonthOrWeek(this._newvalue.substr(currValue), letters, type);
+        if (array[max].trim().length >= letters) {
+            buffer.Append(array[max].trim().substr(0, letters));
+        }
+        else {
+            buffer.Append(array[max].trim());
+            for (let i = letters - array[max].trim().length; i > 0; i = i - 1) {
+                buffer.Append(' ');
+            }
+        }
+        return currValue + letters;
+    }
+    getEndOfNumericBlock(currValue) {
+        while (currValue < this._newvalue.length && !UtilStrByteMode.isDigit(this._newvalue.charAt(currValue))) {
+            currValue = currValue + 1;
+        }
+        return currValue;
+    }
+    addDateSuffix(last) {
+        let thenumber = NNumber.Parse(last);
+        if (thenumber === 1 || thenumber === 21 || thenumber === 31)
+            return "st";
+        else if (thenumber === 2 || thenumber === 22)
+            return "nd";
+        else if (thenumber === 3 || thenumber === 23)
+            return "rd";
+        return "th";
+    }
+    getSizeOfBlock(start, type) {
+        let letters = start + 1;
+        while (letters < this._picture.length && this._picture.charCodeAt(letters) === type)
+            letters++;
+        return letters - start;
+    }
+    getMonthOrWeek(month_str, letters, type) {
+        let array;
+        if (type === PICInterface.PIC_MMM || type === PICInterface.PIC_MMD) {
+            if (this.hebrew)
+                array = HebrewDate.GetLocalMonths();
+            else {
+                let monthStr = Events.GetMessageString(MsgInterface.MONTHS_PTR);
+                array = DateUtil.getLocalMonths(monthStr.toString());
+            }
+        }
+        else if (type === PICInterface.PIC_WWW || type === PICInterface.PIC_W) {
+            if (this.hebrew)
+                array = HebrewDate.GetLocalDows();
+            else {
+                let dayStr = Events.GetMessageString(MsgInterface.DAYS_PTR);
+                array = DateUtil.getLocalDays(dayStr.toString());
+            }
+        }
+        else if (type === PICInterface.PIC_BB) {
+            array = UtilDateJpn.getArrayDow();
+        }
+        else {
+            return 1;
+        }
+        if (letters > month_str.length)
+            letters = month_str.length;
+        if (this.hebrew) {
+            let hstr = NString.TrimStart(month_str).substr(0, letters).trim();
+            for (let i = 1; i < array.length; i++) {
+                if (array[i].trim() === hstr) {
+                    if (i === 14)
+                        i = 6;
+                    return i;
+                }
+            }
+            return 0;
+        }
+        try {
+            let str = month_str.substr(0, letters).trim();
+            let numBuffer = new StringBuilder(str.length);
+            for (let i = 0; i < str.length; i++) {
+                if (UtilStrByteMode.isDigit(str[i]))
+                    numBuffer.Append(str[i]);
+                else
+                    break;
+            }
+            let theNumber = NNumber.Parse(numBuffer.ToString());
+            if (theNumber < 1)
+                return 1;
+            if (type === PICInterface.PIC_MMM || type === PICInterface.PIC_MMD) {
+                if (theNumber > 12)
+                    return 12;
+            }
+            else if (type === PICInterface.PIC_WWW || type === PICInterface.PIC_W || type === PICInterface.PIC_BB) {
+                if (theNumber > 7)
+                    return 7;
+            }
+            return theNumber;
+        }
+        catch (ex_21A) {
+        }
+        let found = new Array(array.length);
+        let from;
+        let max = -1;
+        for (let tmp = 1; tmp < array.length; tmp++) {
+            found[tmp] = 0;
+            from = 0;
+            for (let i = 0; i < array[tmp].length && from < month_str.length && i < letters; i++, from++) {
+                if (array[tmp].toLowerCase()[i] === month_str.toLowerCase()[from])
+                    found[tmp]++;
+                else
+                    break;
+            }
+            if (from === letters || from === array[tmp].length) {
+                max = tmp;
+                break;
+            }
+        }
+        if (max === -1)
+            max = this.findMax(found);
+        return max;
+    }
+    isNumberAllowedInDate() {
+        for (let i = 0; i < this._picture.length; i++) {
+            if (this.isDatePositionalNumericDirective(this._picture[i]))
+                return true;
+        }
+        return false;
+    }
+    isAllNumbers0() {
+        let currChr;
+        for (let i = 0; i < this._newvalue.length; i++) {
+            currChr = this._newvalue[i];
+            if (UtilStrByteMode.isDigit(currChr) && currChr !== '0')
+                return false;
+        }
+        return true;
+    }
+    checkCentury(yearIn) {
+        let outVal;
+        let start_century = this._environment.GetCentury(this._valDet.getControl().getForm().getTask().getCompIdx());
+        let century = Math.floor(start_century / 100);
+        let years = start_century % 100;
+        if (yearIn >= years && yearIn !== 0)
+            outVal = (century * 100 + yearIn);
+        else
+            outVal = ((++century) * 100 + yearIn);
+        return new StringBuilder(outVal.toString());
+    }
+    isDateLegal4Range(ContinuousRange, DiscreteRange, currDate) {
+        let pic = this._valDet.getPIC();
+        let i;
+        let downDate;
+        let topDate;
+        if (ContinuousRange != null) {
+            for (i = 0; i < ContinuousRange.length - 1; i++) {
+                downDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());
+                topDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(++i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());
+                if (currDate >= downDate && currDate <= topDate)
+                    return true;
+            }
+        }
+        if (DiscreteRange != null) {
+            for (i = 0; i < DiscreteRange.length; i++) {
+                if (currDate === DisplayConvertor.Instance.a_2_date_pic(DiscreteRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx()))
+                    return true;
+            }
+        }
+        throw new WrongFormatException();
+    }
+    fillDateByRange(ContinuousRange, DiscreteRange, buffer) {
+        let pic = this._valDet.getPIC();
+        let i;
+        let downDate;
+        let topDate;
+        let currDate = DisplayConvertor.Instance.fromNativeDateToMgDateNumber(buffer, pic);
+        this.setValidationFailed(false);
+        if (ContinuousRange != null) {
+            for (i = 0; i < ContinuousRange.length - 1; i++) {
+                downDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());
+                topDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(++i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());
+                if (currDate >= downDate && currDate <= topDate)
+                    return new Date(buffer);
+            }
+        }
+        if (DiscreteRange != null) {
+            for (i = 0; i < DiscreteRange.length; i++) {
+                if (currDate === DisplayConvertor.Instance.a_2_date_pic(DiscreteRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx())) {
+                    return new Date(buffer);
+                }
+            }
+        }
+        throw new WrongFormatException();
+    }
+    checkDay(date, isDoy) {
+        let day = this.getDateElement(date, DateElement.DAY);
+        if (day < 29 && !isDoy)
+            return new StringBuilder(date);
+        let year = this.getDateElement(date, DateElement.YEAR);
+        if (!isDoy) {
+            if (year.toString().length < 3)
+                year = NNumber.Parse(this.checkCentury(year).ToString());
+            if (this._environment.GetDateMode(this._valDet.getControl().getForm().getTask().getCompIdx()) === 'B')
+                year -= PICInterface.DATE_BUDDHIST_GAP;
+            let month = this.getDateElement(date, DateElement.MONTH);
+            let dayMax = this.getMaxDayInMonth(year, month);
+            if (day > dayMax) {
+                throw new WrongFormatException(MsgInterface.STR_ERR_DATE);
+            }
+        }
+        else {
+            let monthReal = this.getMonthByDay(year, day);
+            if (monthReal < 1 || monthReal > 12)
+                throw new WrongFormatException(MsgInterface.STR_ERR_DATE);
+        }
+        return new StringBuilder(date);
+    }
+    checkWeek(date) {
+        let dow = this.getDateElement(date, DateElement.DOW);
+        let breakParams = DisplayConvertor.Instance.getNewDateBreakParams();
+        let dateMagic = DisplayConvertor.Instance.a_2_date(date, this._picture, this._valDet.getControl().getForm().getTask().getCompIdx());
+        DisplayConvertor.Instance.date_break_datemode(breakParams, dateMagic, true, this._valDet.getControl().getForm().getTask().getCompIdx());
+        let dowReal = breakParams.dow;
+        if (dowReal !== dowReal)
+            date = this.changeDow(date, dowReal);
+        return new StringBuilder(date);
+    }
+    checkJpnEraYear(strDate) {
+        let breakParams = DisplayConvertor.Instance.getNewDateBreakParams();
+        let dateMagic = DisplayConvertor.Instance.a_2_date(strDate, this._picture, this._valDet.getControl().getForm().getTask().getCompIdx());
+        DisplayConvertor.Instance.date_break_datemode(breakParams, dateMagic, true, this._valDet.getControl().getForm().getTask().getCompIdx());
+        let intYearAD = breakParams.year;
+        let intDoy = breakParams.doy;
+        let strEraAlpha;
+        let strEraKanji;
+        strEraAlpha = UtilDateJpn.getInstance().date_jpn_yr_2_a(intYearAD, intDoy, false);
+        strEraKanji = UtilDateJpn.getInstance().date_jpn_yr_2_a(intYearAD, intDoy, true);
+        let strYearJpnEra = new StringBuilder();
+        let num = UtilDateJpn.getInstance().date_jpn_year_ofs(intYearAD, intDoy);
+        if (num <= 0) {
+            throw new WrongFormatException(MsgInterface.STR_ERR_DATE);
+        }
+        if (num <= 9) {
+            strYearJpnEra.Append("0");
+        }
+        strYearJpnEra.Append(num.toString());
+        let intPicIdxOfs = 0;
+        for (let intCnt = 0; intCnt + intPicIdxOfs < this._picture.length; intCnt++) {
+            switch (this._picture.charCodeAt(intCnt + intPicIdxOfs)) {
+                case (PICInterface.PIC_JY1):
+                    strDate = UtilStrByteMode.repC(strDate, strEraAlpha, intCnt + 1, 1);
+                    break;
+                case (PICInterface.PIC_JY2):
+                    strDate = UtilStrByteMode.repC(strDate, strEraKanji, intCnt + 1, 1);
+                    intPicIdxOfs++;
+                    break;
+                case (PICInterface.PIC_JY4):
+                    strDate = UtilStrByteMode.repC(strDate, strEraKanji, intCnt + 1, 2);
+                    intCnt++;
+                    intPicIdxOfs += 2;
+                    break;
+                case (PICInterface.PIC_YJ):
+                    strDate = UtilStrByteMode.repC(strDate, strYearJpnEra.toString(), intCnt + 1, 2);
+                    intCnt++;
+                    break;
+                default:
+                    if (intCnt < strDate.length) {
+                        if (UtilStrByteMode.isHalfWidth(strDate[intCnt]) === false && UtilStrByteMode.isHalfWidth(this._picture[intCnt + intPicIdxOfs]) === true)
+                            intPicIdxOfs++;
+                    }
+                    break;
+            }
+        }
+        return new StringBuilder(strDate);
+    }
+    getMaxDayInMonth(year, month) {
+        let array = [
+            0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+        ];
+        let leapyear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+        if (leapyear && month === 2)
+            return array[month] + 1;
+        return array[month];
+    }
+    getMonthByDay(year, day) {
+        let i;
+        let LeapYear;
+        LeapYear = (year % 4 === 0) && ((year % 100 !== 0) || (year % 400 === 0));
+        for (i = 0; i < PICInterface.date_day_tab.length; i++) {
+            if (!LeapYear) {
+                if (PICInterface.date_day_tab[i] >= day)
+                    return i;
+            }
+            else {
+                if (i < 3) {
+                    if (PICInterface.date_day_tab[i] >= day)
+                        return i;
+                }
+                else {
+                    if (PICInterface.date_day_tab[i] + 1 >= day)
+                        return i;
+                }
+            }
+        }
+        return i;
+    }
+    getDateElement(date, element) {
+        let buffer = null;
+        let letters = 0;
+        let exitLoop = false;
+        let picWeekType = PICInterface.PIC_WWW;
+        let isJpnEraYear = false;
+        let era_year = 0;
+        let intPicIdxOfs = 0;
+        let minLen = 0;
+        if (UtilStrByteMode.isLocaleDefLangJPN())
+            minLen = UtilStrByteMode.getMinLenPicture(date, this._picture);
+        else
+            minLen = Math.min(date.length, this._picture.length);
+        for (let i = 0; i + intPicIdxOfs < minLen && !exitLoop; i++) {
+            if (this.isDataPositionalDirective(this._picture[i + intPicIdxOfs])) {
+                switch (this._picture.charCodeAt(i + intPicIdxOfs)) {
+                    case PICInterface.PIC_DD:
+                        if (element === DateElement.DAY) {
+                            buffer = date.substr(i, 2);
+                            exitLoop = true;
+                            break;
+                        }
+                        i++;
+                        break;
+                    case PICInterface.PIC_DDD:
+                        if (element === DateElement.DAY) {
+                            buffer = date.substr(i, 3);
+                            exitLoop = true;
+                            break;
+                        }
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_DDDD:
+                        if (element === DateElement.DAY) {
+                            buffer = date.substr(i, 2);
+                            exitLoop = true;
+                        }
+                        i += 3;
+                        break;
+                    case PICInterface.PIC_MMD:
+                        if (element === DateElement.MONTH) {
+                            buffer = date.substr(i, 2);
+                            exitLoop = true;
+                        }
+                        i++;
+                        break;
+                    case PICInterface.PIC_MMM:
+                        letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_MMM);
+                        if (element === DateElement.MONTH) {
+                            buffer = date.substr(i, letters);
+                            exitLoop = true;
+                            break;
+                        }
+                        i += letters - 1;
+                        letters = 0;
+                        break;
+                    case PICInterface.PIC_YY:
+                        if (element === DateElement.YEAR) {
+                            buffer = date.substr(i, 2);
+                            exitLoop = true;
+                        }
+                        i++;
+                        break;
+                    case PICInterface.PIC_YYYY:
+                        if (element === DateElement.YEAR) {
+                            buffer = date.substr(i, 4);
+                            exitLoop = true;
+                        }
+                        i += 3;
+                        break;
+                    case PICInterface.PIC_W:
+                        if (element === DateElement.DOW) {
+                            buffer = date.substr(i, 1);
+                            exitLoop = true;
+                        }
+                        break;
+                    case PICInterface.PIC_WWW:
+                        letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_WWW);
+                        if (element === DateElement.DOW) {
+                            buffer = date.substr(i, letters);
+                            exitLoop = true;
+                            break;
+                        }
+                        i += letters - 1;
+                        letters = 0;
+                        break;
+                    case PICInterface.PIC_HYYYYY:
+                    case PICInterface.PIC_HL:
+                    case PICInterface.PIC_HDD:
+                        break;
+                    case PICInterface.PIC_BB:
+                        letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_BB);
+                        if (i + Math.floor(letters / 2) < date.length) {
+                            buffer = date.substr(i, Math.floor(letters / 2));
+                            intPicIdxOfs += letters - buffer.length;
+                        }
+                        if (element === DateElement.DOW) {
+                            exitLoop = true;
+                            picWeekType = PICInterface.PIC_BB;
+                        }
+                        else {
+                            buffer = null;
+                        }
+                        i += letters - 1;
+                        break;
+                    case PICInterface.PIC_JY1:
+                        isJpnEraYear = true;
+                        break;
+                    case PICInterface.PIC_JY2:
+                        isJpnEraYear = true;
+                        intPicIdxOfs++;
+                        break;
+                    case PICInterface.PIC_JY4:
+                        isJpnEraYear = true;
+                        intPicIdxOfs += 2;
+                        i++;
+                        break;
+                    case PICInterface.PIC_YJ:
+                        if (element === DateElement.YEAR) {
+                            buffer = date.substr(i, 2);
+                            exitLoop = true;
+                        }
+                        i++;
+                        break;
+                }
+            }
+        }
+        if (buffer == null) {
+            if (element === DateElement.YEAR)
+                return DateTime.Now.Year;
+            else
+                return 1;
+        }
+        buffer = buffer.trim();
+        if (letters > 0) {
+            if (element === DateElement.MONTH)
+                letters = this.getMonthOrWeek(buffer.toString(), letters, PICInterface.PIC_MMM);
+            else if (element === DateElement.DOW)
+                letters = this.getMonthOrWeek(buffer.toString(), letters, picWeekType);
+        }
+        else {
+            while (buffer.toString().startsWith("0") || buffer.toString().startsWith(" "))
+                buffer = buffer.toString().substr(1);
+            if (buffer.length === 0)
+                letters = 0;
+            else
+                letters = NNumber.Parse(buffer.toString());
+        }
+        if (element === DateElement.YEAR && isJpnEraYear) {
+            era_year = UtilDateJpn.getInstance().getStartYearOfEra(date, this._picture);
+            if (era_year === 0)
+                return 0;
+            letters += era_year - 1;
+        }
+        return letters;
+    }
+    changeDow(date, dow) {
+        let isDate = false;
+        let letters;
+        let startPart;
+        let finishPart;
+        let number1;
+        number1 = "" + dow;
+        let intPicIdxOfs = 0;
+        for (let i = 0; i + intPicIdxOfs < this._picture.length && !isDate; i++) {
+            if (this.isDataPositionalDirective(this._picture[i + intPicIdxOfs])) {
+                switch (this._picture.charCodeAt(i + intPicIdxOfs)) {
+                    case PICInterface.PIC_W:
+                        startPart = date.substr(0, i);
+                        finishPart = date.substr(i + 1);
+                        date = startPart + number1 + finishPart;
+                        isDate = true;
+                        break;
+                    case PICInterface.PIC_WWW:
+                        letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_WWW);
+                        startPart = date.substr(0, i);
+                        finishPart = date.substr(i + letters);
+                        let dayStr = Events.GetMessageString(MsgInterface.DAYS_PTR);
+                        let dayNames = DateUtil.getLocalDays(dayStr);
+                        number1 = dayNames[dow];
+                        if (number1.length > letters)
+                            number1 = number1.substr(0, letters);
+                        else if (number1.length < letters)
+                            while (number1.length < letters)
+                                number1 = number1 + ' ';
+                        date = startPart + number1 + finishPart;
+                        isDate = true;
+                        break;
+                    case PICInterface.PIC_BB:
+                        letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_BB);
+                        startPart = date.substr(0, i);
+                        finishPart = date.substr(i + Math.floor(letters / 2));
+                        number1 = UtilDateJpn.getStrDow(dow);
+                        if (UtilStrByteMode.lenB(number1) > letters)
+                            number1 = UtilStrByteMode.leftB(number1, letters);
+                        else if (UtilStrByteMode.lenB(number1) < letters)
+                            while (UtilStrByteMode.lenB(number1) < letters)
+                                number1 = number1 + ' ';
+                        date = startPart + number1 + finishPart;
+                        isDate = true;
+                        break;
+                    default:
+                        if (UtilStrByteMode.isLocaleDefLangDBCS()) {
+                            if (i < date.length) {
+                                if (UtilStrByteMode.isHalfWidth(date[i]) === false && UtilStrByteMode.isHalfWidth(this._picture[i + intPicIdxOfs]) === true)
+                                    intPicIdxOfs++;
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+        return date;
+    }
+    checkTimeField() {
+        let newTime = new Date(this._newvalue);
+        this.setValidationFailed(false);
+        if (this._valDet.getControl().isDateZero(this._newvalue)) {
+            let defaultMgValue = this._valDet.getControl().getField().getDefaultValue();
+            newTime = DisplayConvertor.Instance.mg2disp(defaultMgValue, "", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), false);
+        }
+        else {
+            if (this._valDet.getContinuousRangeValues() != null || this._valDet.getDiscreteRangeValues() != null)
+                newTime = this.fillTimeByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues(), this._newvalue);
+        }
+        return newTime;
+    }
+    add2Time(currValue, buffer, type) {
+        let start = currValue;
+        let i;
+        let STR_00 = "00";
+        let currAdd = new StringBuilder();
+        while (start < this._newvalue.length && !UtilStrByteMode.isDigit(this._newvalue[start])) {
+            start++;
+        }
+        if (start === this._newvalue.length) {
+            buffer.Append(STR_00.toString());
+            return currValue;
+        }
+        for (i = start; i < start + 2 && i < this._newvalue.length; i++) {
+            if (UtilStrByteMode.isDigit(this._newvalue[i]))
+                currAdd.Append(this._newvalue[i]);
+            else {
+                currAdd.Insert(0, '0');
+                break;
+            }
+        }
+        if (i === this._newvalue.length && i === start + 1)
+            currAdd.Insert(0, '0');
+        else if (i === this._newvalue.length && i === start)
+            currAdd.Append(STR_00.toString());
+        let add = NNumber.Parse(currAdd.ToString());
+        if (add < 0 || (add > 59 && type === PICInterface.PIC_MMT) || (add > 59 && type === PICInterface.PIC_SS))
+            throw new WrongFormatException(MsgInterface.STR_ERR_TIME);
+        else if (type === PICInterface.PIC_HH) {
+            let PM = this.getIsPM();
+            let newStr = null;
+            let dif;
+            if ((add >= 12 || add === 0) && PM) {
+                let addTmp = add % 24;
+                this._isPm = (addTmp >= 12 && addTmp < 24);
+                if (addTmp > 12)
+                    dif = addTmp - 12;
+                else if (addTmp === 0)
+                    dif = 12;
+                else
+                    dif = addTmp;
+                newStr = ((dif > 9 ? "" : "0") + dif);
+            }
+            else if (add > 99 && !PM)
+                newStr = "99";
+            if (newStr != null) {
+                currAdd.Remove(0, currAdd.Length);
+                currAdd.Append(newStr.toString());
+            }
+        }
+        buffer.Append(currAdd.ToString());
+        return i;
+    }
+    addPM2Time(currValue, buffer) {
+        let i;
+        if ((i = this._newvalue.toUpperCase().indexOf("AM", currValue)) !== -1) {
+            buffer.Append("am");
+            return i + 2;
+        }
+        else {
+            if ((i = this._newvalue.toUpperCase().indexOf("PM", currValue)) !== -1) {
+                buffer.Append("pm");
+                return i + 2;
+            }
+            else if (this._isPm) {
+                buffer.Append("pm");
+                return currValue;
+            }
+            else
+                buffer.Append("am");
+        }
+        return currValue;
+    }
+    getIsPM() {
+        for (let curr = 0; curr < this._picture.length; curr++) {
+            if (this._picture.charCodeAt(curr) === PICInterface.PIC_PM)
+                return true;
+        }
+        return false;
+    }
+    fillTimeByRange(ContinuousRange, DiscreteRange, buffer) {
+        let pic = this._valDet.getPIC();
+        let currTime = DisplayConvertor.Instance.fromNativeTimeToMgTimeNumber(buffer);
+        let downTime, topTime;
+        let i;
+        this.setValidationFailed(false);
+        if (ContinuousRange != null) {
+            for (i = 0; i < ContinuousRange.length - 1; i++) {
+                downTime = DisplayConvertor.Instance.a_2_time(ContinuousRange.get_Item(i), pic, false);
+                topTime = DisplayConvertor.Instance.a_2_time(ContinuousRange.get_Item(++i), pic, false);
+                if (currTime >= downTime && currTime <= topTime)
+                    return new Date(buffer);
+            }
+        }
+        if (DiscreteRange != null) {
+            for (i = 0; i < DiscreteRange.length; i++) {
+                if (currTime === DisplayConvertor.Instance.a_2_time(DiscreteRange.get_Item(i), pic, false))
+                    return new Date(buffer);
+            }
+        }
+        throw new WrongFormatException();
+    }
+    printMessage(msgId, setValidationFaild) {
+        let message = new StringBuilder("");
+        let ctrlType;
+        if (msgId === MsgInterface.EDT_ERR_STR_1) {
+            let pic = this._valDet.getPIC();
+            let token = "%d";
+            let messageString = Events.GetMessageString(msgId);
+            messageString = StrUtil.replaceStringTokens(messageString, token, 1, pic.getWholes().toString());
+            messageString = StrUtil.replaceStringTokens(messageString, token, 1, pic.getDec().toString());
+            message.Append(messageString);
+        }
+        else {
+            message.Append(Events.GetMessageString(msgId));
+            if (msgId === MsgInterface.STR_RNG_TXT && this._valDet.getRange() != null)
+                message.Append(StrUtil.makePrintableTokens(this._valDet.getRange(), HTML_2_STR));
+        }
+        if (this._valDet.getControl() != null) {
+            ctrlType = this._valDet.getControl().Type;
+            if (ctrlType !== MgControlType.CTRL_TYPE_BUTTON && ctrlType !== MgControlType.CTRL_TYPE_RADIO && !this._valDet.getControl().isSelectionCtrl()) {
+                let msgString = message.ToString();
+                this._valDet.getControl().getForm().getTask().WriteToMessagePane(StrUtil.makePrintable2(msgString));
+                this._valDet.getControl().getForm().ErrorOccured = !NString.IsNullOrEmpty(msgString);
+                this._valDet.ErrorMessage = message.ToString();
+            }
+        }
+        if (setValidationFaild)
+            this.setValidationFailed(true);
+    }
+    changeStringInside(to, index) {
+        this._newvalue = this._newvalue.substr(0, index) + to + this._newvalue.substr(index + to.length);
+    }
+    init(validationDetails) {
+        this._valDet = validationDetails;
+        this._valDet.setNull(false);
+        this._isPm = false;
+        let pIC = this._valDet.getPIC();
+        this._oldvalue = this._valDet.getOldValue();
+        this._newvalue = this._valDet.getDispValue();
+        if (this._newvalue === null) {
+            if (pIC == null || pIC.getAttr() != StorageAttribute.DATE)
+                this._newvalue = "";
+        }
+        if (this._oldvalue === null) {
+            this._oldvalue = "";
+        }
+        if (!(pIC === null || pIC.getAttr() === StorageAttribute.BLOB || pIC.getAttr() === StorageAttribute.BLOB_VECTOR)) {
+            this._picture = pIC.getMask();
+            this.hebrew = pIC.isHebrew();
+            this._picture = this._picture.substr(0, pIC.getMaskSize());
+        }
+    }
+    findMax(array) {
+        let index = 0;
+        let max = array[index];
+        for (let i = 1; i < array.length; i++) {
+            if (array[i] > max) {
+                max = array[i];
+                index = i;
+            }
+        }
+        return index;
+    }
+    isDataPositionalDirective(toCheck) {
+        let ascii = toCheck.charCodeAt(0);
+        return (ascii === PICInterface.PIC_YY || ascii === PICInterface.PIC_YYYY || ascii === PICInterface.PIC_MMD || ascii === PICInterface.PIC_MMM
+            || ascii === PICInterface.PIC_DD || ascii === PICInterface.PIC_DDD || ascii === PICInterface.PIC_DDDD || ascii === PICInterface.PIC_W
+            || ascii === PICInterface.PIC_WWW || ascii === PICInterface.PIC_HYYYYY || ascii === PICInterface.PIC_HL || ascii === PICInterface.PIC_HDD || ascii === PICInterface.PIC_YJ
+            || ascii === PICInterface.PIC_JY1 || ascii === PICInterface.PIC_JY2 || ascii === PICInterface.PIC_JY4 || ascii === PICInterface.PIC_BB);
+    }
+    isDatePositionalNumericDirective(toCheck) {
+        let ascii = toCheck.charCodeAt(0);
+        return (ascii === PICInterface.PIC_YY || ascii === PICInterface.PIC_YYYY || ascii === PICInterface.PIC_MMD || ascii === PICInterface.PIC_DD
+            || ascii === PICInterface.PIC_DDD || ascii === PICInterface.PIC_DDDD || ascii === PICInterface.PIC_W || ascii === PICInterface.PIC_HYYYYY
+            || ascii === PICInterface.PIC_HL || ascii === PICInterface.PIC_HDD || ascii === PICInterface.PIC_YJ || ascii === PICInterface.PIC_JY1
+            || ascii === PICInterface.PIC_JY2 || ascii === PICInterface.PIC_JY4 || ascii === PICInterface.PIC_BB);
+    }
+    isNumericPositionalDirective(toCheck) {
+        let ascii = toCheck.charCodeAt(0);
+        return (ascii === PICInterface.PIC_N);
+    }
+    isLogicPositionalDirective(toCheck) {
+        let ascii = toCheck.charCodeAt(0);
+        return (ascii === PICInterface.PIC_X);
+    }
+    isTimePositionalDirective(toCheck) {
+        let ascii = toCheck.charCodeAt(0);
+        return (ascii === PICInterface.PIC_HH || ascii === PICInterface.PIC_MMT || ascii === PICInterface.PIC_SS || ascii === PICInterface.PIC_PM || ascii === PICInterface.PIC_MS);
+    }
+    indexOfPositionalNonDirective(str) {
+        let tmp;
+        for (let i = 0; i < str.length; i++) {
+            tmp = str[i];
+            if (DisplayConvertor.isAlphaPositionalDirective(tmp) || this.isDataPositionalDirective(tmp) || this.isNumericPositionalDirective(tmp)
+                || this.isLogicPositionalDirective(tmp) || this.isTimePositionalDirective(tmp))
+                continue;
+            return i;
+        }
+        return -1;
+    }
+    setValidationFailed(val) {
+        if (this._valDet.ValidationFailed)
+            return;
+        else
+            this._valDet.setValidationFailed(val);
+    }
+    digitsBeforeDelimeter(inputString, searchStart, delimeter) {
+        let counter = 0;
+        let searchEndPos = inputString.indexOf(delimeter, searchStart);
+        if (searchEndPos < 0)
+            searchEndPos = inputString.length;
+        for (let i = searchStart; i < searchEndPos; i++)
+            if (NChar.IsDigit(inputString[i]))
+                counter++;
+        return counter;
+    }
+    isNullDisplayVal() {
+        let isNullDisplayVal = false;
+        let field = this._valDet.getControl().getField();
+        if (field.NullAllowed && field.hasNullDisplayValue()) {
+            let dispDefValue = field.getNullDisplay();
+            if (dispDefValue !== null)
+                isNullDisplayVal = (dispDefValue.toString() === this._newvalue);
+            else
+                isNullDisplayVal = (this._newvalue === null);
+        }
+        return isNullDisplayVal;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FieldValidator.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/gui/FieldValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  DateTime,\r\n  Exception,\r\n  List,\r\n  NChar,\r\n  NNumber,\r\n  NString,\r\n  NumberFormatInfo,\r\n  StringBuilder\r\n} from '@magic-xpa/mscorelib';\r\nimport {ValidationDetails} from './ValidationDetails';\r\nimport {IEnvironment} from '../../env/IEnvironment';\r\nimport {MgControlBase} from './MgControlBase';\r\nimport {GuiFieldBase} from '../data/GuiFieldBase';\r\nimport {DateBreakParams, DisplayConvertor} from './DisplayConvertor';\r\nimport {\r\n  DateUtil,\r\n  HTML_2_STR,\r\n  MgControlType,\r\n  MsgInterface,\r\n  PICInterface,\r\n  StorageAttribute,\r\n  StrUtil,\r\n  UtilDateJpn,\r\n  UtilStrByteMode\r\n} from '@magic-xpa/utils';\r\nimport {Events} from '../../Events';\r\nimport {WrongFormatException} from './WrongFormatException';\r\nimport {PIC} from './PIC';\r\nimport {DateElement} from '../../GuiEnums';\r\nimport {NUM_TYPE} from '../data/NUM_TYPE';\r\nimport {HebrewDate} from './HebrewDate';\r\nimport {BlobType} from '../data/BlobType';\r\nimport {GuiEnvironment} from '../../GuiEnvironment';\r\nimport {PropInterface} from \"./PropInterface\";\r\n\r\n\r\nexport class FieldValidator {\r\n  private _newvalue: any = null;\r\n  private _oldvalue: any = null;\r\n  private _pictureReal: string = null;\r\n  private _pictureEnable: string = null;\r\n  private _valDet: ValidationDetails = null;\r\n  private _isPm: boolean = false;\r\n  private _picture: string = null;\r\n  private hebrew: boolean = false;\r\n  private _decimal: string = null;\r\n  private _environment: IEnvironment = null;\r\n\r\n  constructor() {\r\n    this._environment = GuiEnvironment.Environment;\r\n    this._decimal = (this._environment.GetDecimal() || \"\");\r\n  }\r\n\r\n  /// <summary> the main method of this class</summary>\r\n  /// <param name=\"valDet\">a ValidationDetails object to use when validating</param>\r\n  checkVal(valDet: ValidationDetails): ValidationDetails {\r\n    this._newvalue = (this._oldvalue = (this._pictureReal = (this._pictureEnable = null)));\r\n    this.init(valDet);\r\n    valDet.setValidationFailed(false);\r\n    let ctrl: MgControlBase = valDet.getControl();\r\n    // TODO - uncomment this line when 'PROP_TYPE_MODIFY_IN_QUERY' is supported for other controls\r\n    let modInQueuy: boolean =\r\n      ctrl.isRepeatable()? false :  ctrl.GetComputedBooleanProperty(PropInterface.PROP_TYPE_MODIFY_IN_QUERY, false, ctrl.getDisplayLine(false));\r\n\r\n    let useNative: boolean = ctrl.isModifiable();\r\n\r\n    if (ctrl.getForm().getTask().getMode() === 'E' && !modInQueuy) {\r\n      valDet.setValue(this._oldvalue);\r\n      return valDet;\r\n    }\r\n\r\n    if (ctrl.Type === MgControlType.CTRL_TYPE_RADIO || ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX || ctrl.Type === MgControlType.CTRL_TYPE_TAB || ctrl.isSelectionCtrl()) {\r\n      try {\r\n        if (ctrl.Type === MgControlType.CTRL_TYPE_CHECKBOX) {\r\n          valDet.setNull(ctrl.isNullValue(this._newvalue));\r\n        }\r\n        if (this._newvalue !== null && ctrl.isSelectionCtrl()) {\r\n          let idx: number = NNumber.Parse(this._newvalue);\r\n          if (ctrl.isChoiceNull(idx)) {\r\n            valDet.setNull(true);\r\n          }\r\n        }\r\n      }\r\n      catch (ex_111) {\r\n        if (ex_111 instanceof Exception) {\r\n        }\r\n        else\r\n          throw ex_111;\r\n      }\r\n      valDet.setValue(this._newvalue);\r\n      return valDet;\r\n    }\r\n\r\n    // space|nothing was inserted  -> use default value\r\n    if (ctrl.DataType !== StorageAttribute.ALPHA && ctrl.DataType !== StorageAttribute.UNICODE && ctrl.DataType !== StorageAttribute.BLOB) {\r\n          if ((typeof this._newvalue === 'string' && this._newvalue.trim().length === 0) || (ctrl.DataType === StorageAttribute.DATE && (ctrl.isDateZero(this._newvalue) || this.isNullDisplayVal()))) {\r\n            let field: GuiFieldBase = ctrl.getField();\r\n            let defaultValue: string = field.getDefaultValue();\r\n            let text: any = null;\r\n            if (field.isNullDefault()) {\r\n              valDet.setNull(true);\r\n              text = field.getNullDisplay();\r\n              if (NString.IsNullOrEmpty(text) && ctrl.DataType === StorageAttribute.DATE) {\r\n                text = DisplayConvertor.Instance.mg2disp(defaultValue, valDet.getRange(), valDet.getPIC(), useNative, field.getTask().getCompIdx(), false);\r\n              }\r\n            }\r\n            if (text === null) {\r\n              text = DisplayConvertor.Instance.mg2disp(defaultValue, valDet.getRange(), valDet.getPIC(), useNative, field.getTask().getCompIdx(), false);\r\n            }\r\n            if ((!field.isNullDefault() && (this._valDet.getContinuousRangeValues() !== null || this._valDet.getDiscreteRangeValues() !== null)))\r\n              this._newvalue = text;\r\n            else\r\n            {\r\n              valDet.setValue(text);\r\n              return valDet;\r\n            }\r\n          }\r\n     }\r\n\r\n\r\n    if ((typeof this._newvalue === 'string' && !(StrUtil.rtrim(this._newvalue) === StrUtil.rtrim(this._oldvalue))) || ctrl.ModifiedByUser)\r\n    {\r\n      try\r\n      {\r\n        switch (valDet.getType())\r\n        {\r\n\r\n          case StorageAttribute.ALPHA:\r\n          case StorageAttribute.UNICODE:\r\n            valDet.setValue(this.checkAlphaField());\r\n            break;\r\n\r\n          case StorageAttribute.NUMERIC:\r\n            this._pictureReal = valDet.getPictureReal(); // only numeric type need another picture format\r\n            this._pictureEnable = valDet.getPictureEnable();\r\n            this.checkNumericPicture();\r\n            valDet.setValue(this.checkNumericField());\r\n            break;\r\n\r\n          case StorageAttribute.BOOLEAN:\r\n            valDet.setValue(this.checkLogicalField());\r\n            break;\r\n\r\n          case StorageAttribute.DATE:\r\n            valDet.setValue(this.checkDateField());\r\n            break;\r\n\r\n          case StorageAttribute.TIME:\r\n            valDet.setValue(this.checkTimeField());\r\n            break;\r\n\r\n          case StorageAttribute.BLOB:\r\n          // there is no real picture to BLOB, do nothing\r\n          case StorageAttribute.BLOB_VECTOR:\r\n            valDet.setValue(this._newvalue);\r\n            break;\r\n\r\n          case StorageAttribute.NONE:\r\n          default:\r\n            Events.WriteExceptionToLog(\"FieldValidator.checkVal: Type of the field \" + valDet.getType());\r\n            break;\r\n        }\r\n      }\r\n      catch (goBack) {\r\n        if (goBack instanceof WrongFormatException) {\r\n          // need change to old value, set focus back and write Error Message\r\n          valDet.setValue(this._oldvalue);\r\n          this.setValidationFailed(true);\r\n          if (goBack.getType() !== MsgInterface.STR_RNG_TXT) {\r\n            this.printMessage(goBack.getType(), false);\r\n            this.setValidationFailed(true);\r\n          }\r\n          else\r\n            this.printMessage(MsgInterface.STR_RNG_TXT, true);\r\n        }\r\n      }\r\n    }\r\n    return valDet;\r\n\r\n  }\r\n\r\n  /// <summary>Check & validate Alpha field by his old/new value and 2 pictures:\r\n  /// Real and Enable\r\n  /// 1.check if newvalue complete with pictures, otherwise return oldvalue\r\n  /// 2.check if newvalue complete with range\r\n  /// 2.1 complete value, if possible, otherwise  return oldvalue\r\n  /// </summary>\r\n  /// <returns> String - new value of validated field</returns>\r\n  private checkAlphaField(): string {\r\n\r\n    let control: MgControlBase = this._valDet.getControl();\r\n\r\n    let IsAttrAlpha: boolean = this._valDet.getType() === StorageAttribute.ALPHA;\r\n\r\n    if (this._newvalue.length === 0 && this._valDet.getContinuousRangeValues() === null && this._valDet.getDiscreteRangeValues() === null) {\r\n      this.setValidationFailed(false);\r\n      return this._newvalue;\r\n    }\r\n\r\n    if (IsAttrAlpha && UtilStrByteMode.isLocaleDefLangDBCS()) {\r\n      let picLenB: number = UtilStrByteMode.lenB(this._picture);\r\n      if (UtilStrByteMode.lenB(this._newvalue) > picLenB) {\r\n        this._newvalue = UtilStrByteMode.leftB(this._newvalue, picLenB);\r\n      }\r\n    }\r\n    else {\r\n      if (this._newvalue.length > this._picture.length) {\r\n        this._newvalue = this._newvalue.substr(0, this._picture.length);\r\n      }\r\n    }\r\n    let stringBuilder: StringBuilder = new StringBuilder();\r\n    let currPicture: number;\r\n    let i: number = currPicture = 0;\r\n\r\n    for (currPicture = i = 0; i < this._newvalue.length && currPicture < this._picture.length; ) {\r\n      if (!DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture)) && this._newvalue.charAt(i) === this._picture.charAt(currPicture)) {\r\n        stringBuilder.Append(this._picture.charAt(currPicture));\r\n        i = i + 1;\r\n        currPicture = currPicture + 1;\r\n      }\r\n      else {\r\n        if (!DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture)) && this._newvalue.charAt(i) !== this._picture.charAt(currPicture)) {\r\n          stringBuilder.Append(this._picture.charAt(currPicture));\r\n          currPicture = currPicture + 1;\r\n        }\r\n        else {\r\n          if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture)) && this.isPossibleAlphaLetter(i, currPicture)) {\r\n            if (UtilStrByteMode.isLocaleDefLangDBCS()) {\r\n              let strVal: string = this._newvalue.substr(i, 1);\r\n              if (UtilStrByteMode.lenB(strVal) === 2) {\r\n                if (IsAttrAlpha) {\r\n                  if (currPicture + 1 < this._picture.length) {\r\n                    if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(currPicture + 1)) && this.isPossibleAlphaLetter(i, currPicture + 1)) {\r\n                      stringBuilder.Append(this._newvalue.charAt(i));\r\n                      i = i + 1;\r\n                      currPicture = currPicture + 2;\r\n                    }\r\n                    else {\r\n                      stringBuilder.Append(' ')/*' '*/;\r\n                      currPicture = currPicture + 1;\r\n                    }\r\n                  }\r\n                  else {\r\n                    stringBuilder.Append(' ')/*' '*/;\r\n                    currPicture = currPicture + 1;\r\n                  }\r\n                }\r\n                else {\r\n                  stringBuilder.Append(this._newvalue.charAt(i));\r\n                  i = i + 1;\r\n                  currPicture = currPicture + 1;\r\n                }\r\n              }\r\n              else {\r\n                stringBuilder.Append(this._newvalue.charAt(i));\r\n                i = i + 1;\r\n                currPicture = currPicture + 1;\r\n              }\r\n            }\r\n            else {\r\n              stringBuilder.Append(this._newvalue.charAt(i));\r\n              i = i + 1;\r\n              currPicture = currPicture + 1;\r\n            }\r\n          }\r\n          else {\r\n            stringBuilder.Append(' ')/*' '*/;\r\n            currPicture = currPicture + 1;\r\n            if (this._valDet.getControl() !== null) {\r\n              let type: MgControlType = control.Type;\r\n              if (type !== MgControlType.CTRL_TYPE_BUTTON) {\r\n                this.printMessage(MsgInterface.STR_ERR_NUM, false);\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    this._newvalue = stringBuilder.ToString();\r\n    if (this._valDet.getContinuousRangeValues() !== null || this._valDet.getDiscreteRangeValues() !== null) {\r\n      this._newvalue = this.fillAlphaByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues());\r\n    }\r\n    return  this._newvalue;\r\n  }\r\n\r\n  /// <summary>check if char in Alpha compleate with Directive Character for the letter</summary>\r\n  /// <param name=\"index\">of directive in string to check</param>\r\n  /// <returns> true if complete, false otherwise</returns>\r\n  private isPossibleAlphaLetter(indexInput: number, indexPicture: number): boolean {\r\n    let result: boolean;\r\n    switch (this._picture.charCodeAt(indexPicture)) {\r\n      case PICInterface.PIC_X:\r\n      case PICInterface.PIC_J:\r\n      case PICInterface.PIC_G:\r\n      case PICInterface.PIC_S:\r\n      case PICInterface.PIC_T:\r\n        return true;\r\n\r\n      case PICInterface.PIC_U:\r\n        let upper: string = this._newvalue[indexInput].toUpperCase();\r\n        if (upper !== this._newvalue[indexInput])\r\n          this.changeStringInside(\"\" + upper, indexInput);\r\n        return true;\r\n\r\n      case PICInterface.PIC_L:\r\n        let lower: string = this._newvalue[indexInput].toLowerCase();\r\n        if (lower !== this._newvalue[indexInput])\r\n          this.changeStringInside(\"\" + lower, indexInput);\r\n        return true;\r\n\r\n      case PICInterface.PIC_N:\r\n        let number1: string = this._newvalue[indexInput];\r\n        if (UtilStrByteMode.isDigit(number1) || NChar.IsWhiteSpace(number1) || UtilStrByteMode.asNumeric(number1))\r\n          return true;\r\n        else\r\n        {\r\n          Events.WriteErrorToLog(\"Bad Alpha value. Should be number only on place Num. \" + indexInput);\r\n          return false;\r\n        }\r\n\r\n      default:\r\n        Events.WriteErrorToLog(\"FieldValidator.isPossibleAlphaLetter: illegal Char Directive: \" + this._picture.indexOf(String.fromCharCode(indexPicture)) + \" for \" + this._newvalue[indexInput]);\r\n        return false;\r\n    }\r\n  }\r\n\r\n  /// <summary>if new value wasn't finished and stay unwritable peaces of the Real picture - add it\r\n  /// to the end of the newvalue\r\n  /// </summary>\r\n  private fillAllAlpha(): string {\r\n    let stringBuilder: StringBuilder = new StringBuilder(this._picture.length);\r\n    stringBuilder.Append(this._newvalue);\r\n\r\n    if (UtilStrByteMode.isLocaleDefLangDBCS() && this._valDet.getType() === StorageAttribute.ALPHA) {\r\n      let intNewvalueLenB: number = UtilStrByteMode.lenB(this._newvalue);\r\n      let strBuiedPicture: string = UtilStrByteMode.leftB(this._picture, intNewvalueLenB);\r\n      for (let i: number = strBuiedPicture.length; i < this._picture.length; i = i + 1) {\r\n        if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(i))) {\r\n          stringBuilder.Append(' ');\r\n        }\r\n        else {\r\n          stringBuilder.Append(this._picture.charAt(i));\r\n        }\r\n      }\r\n    }\r\n    else {\r\n      for (let i: number = this._newvalue.length - 1; i < this._picture.length && i >= 0; i++) {\r\n        if (DisplayConvertor.isAlphaPositionalDirective(this._picture.charAt(i))) {\r\n          stringBuilder.Append(' ')/*' '*/;\r\n        }\r\n        else {\r\n          stringBuilder.Append(this._picture.charAt(i));\r\n        }\r\n        i = i + 1;\r\n      }\r\n    }\r\n    return stringBuilder.ToString();\r\n  }\r\n\r\n  /// <summary>Comparative newvalue with possible Range in ContinuousRangeValues/DiscreteRangeValues</summary>\r\n  /// <returns> newvalue if it possible, oldvalue otherwise</returns>\r\n  private fillAlphaByRange(ContinuousRangeValues: List<string>, DiscreteRangeValues: List<string>): string {\r\n\r\n    let tmpBuffer: string = DisplayConvertor.Instance.fillAlphaByDiscreteRangeValues(DiscreteRangeValues, this._newvalue);\r\n    if (tmpBuffer !== null) {\r\n      return tmpBuffer;\r\n    }\r\n\r\n    tmpBuffer = DisplayConvertor.Instance.fillAlphaByContinuousRangeValues(ContinuousRangeValues, this._newvalue);\r\n    if (tmpBuffer !== null)\r\n      return tmpBuffer;\r\n\r\n      if (DiscreteRangeValues !== null)\r\n        return this.CompleteAlphaByRange(DiscreteRangeValues);\r\n\r\n\r\n    this.printMessage(MsgInterface.STR_RNG_TXT, true);\r\n    return this._oldvalue;\r\n  }\r\n\r\n  /// <summary>Try to complete the newvalue by Range</summary>\r\n  /// <returns> completed value if it possible, otherwise oldvalue</returns>\r\n  private CompleteAlphaByRange(DiscreteRangeValues: List<string>): string {\r\n    let tmpNewValue: string = DisplayConvertor.Instance.completeAlphaByRange(DiscreteRangeValues, this._newvalue);\r\n    if (tmpNewValue !== null) {\r\n      return tmpNewValue;\r\n    }\r\n\r\n    // focus back\r\n    this.printMessage(MsgInterface.STR_RNG_TXT, true);\r\n    return this._oldvalue;\r\n\r\n  }\r\n\r\n  /// <summary>check & validate Logical field by his old/new value and 2 pictures:\r\n  /// Real and Enable\r\n  /// 1.check if newvalue complete with pictures, otherwise return oldvalue\r\n  /// 2.check if newvalue complete with range\r\n  /// 2.1 complete value, if possible, otherwise  return oldvalue\r\n  /// </summary>\r\n  /// <returns> String - new value of validated field</returns>\r\n  private checkLogicalField(): boolean {\r\n\r\n    if (this._newvalue.length === 0 && this._valDet.getContinuousRangeValues() === null && this._valDet.getDiscreteRangeValues() === null) {\r\n      throw new WrongFormatException(MsgInterface.STR_RNG_TXT);\r\n    }\r\n\r\n    if (this._valDet.getContinuousRangeValues() !== null || this._valDet.getDiscreteRangeValues() !== null) {\r\n      this._newvalue = this.fillAlphaByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues());\r\n    }\r\n\r\n    this.setValidationFailed(false);\r\n\r\n  // todo : need to check what is to handle for checking ranges\r\n    return this._newvalue;\r\n  }\r\n\r\n  /// <summary>**************************Numeric*********************************</summary>\r\n\r\n  /// <summary>check & validate Numeric field by his old/new value and 2 pictures:\r\n  /// Real and Enable\r\n  /// 1.check if newvalue complete with pictures, otherwise return oldvalue\r\n  /// 2.check if newvalue complete with range\r\n  /// 2.1 complete value, if possible, otherwise  return oldvalue\r\n  /// </summary>\r\n  /// <returns> String - new value of validated field</returns>\r\n  private checkNumericField(): any {\r\n\r\n    let evaluated: any;\r\n    if (typeof this._newvalue === 'string') {\r\n      if (this._newvalue.length === 0) {\r\n        this._newvalue = \"0\";\r\n      }\r\n\r\n      let delimeterRealIndex: number = this._newvalue.indexOf(this._decimal);\r\n      let delimeterPictIndex: number = this._pictureReal.indexOf(this._decimal);\r\n\r\n      evaluated = \"\";\r\n      let evaluatedLeft: string;\r\n      let evaluatedRight: string;\r\n\r\n\r\n      this.setValidationFailed(false);\r\n\r\n      // check if the format of newvalue matches the numeric mask.\r\n      if (!this.checkNumericInDecFormat())\r\n        throw new WrongFormatException(MsgInterface.EDT_ERR_STR_1);\r\n\r\n      if (delimeterPictIndex !== -1 && delimeterRealIndex !== -1) {\r\n        evaluatedLeft = this.checkNumericLeft(delimeterPictIndex, delimeterRealIndex);\r\n        evaluatedRight = this.checkNumericRight(delimeterPictIndex, delimeterRealIndex);\r\n        evaluated = evaluatedLeft + this._decimal + evaluatedRight;\r\n      }\r\n      else {\r\n        if (delimeterPictIndex !== -1 && delimeterRealIndex === -1) {\r\n          evaluatedLeft = this.checkNumericLeft(delimeterPictIndex, Math.min(delimeterPictIndex, this._newvalue.length));\r\n          evaluatedRight = this.checkNumericRight(delimeterPictIndex, delimeterPictIndex - 1);\r\n          evaluated = evaluatedLeft + this._decimal + evaluatedRight;\r\n        }\r\n        else { // delimeterPictIndex == -1 && delimeterRealIndex != -1\r\n          if (delimeterPictIndex === -1 && delimeterRealIndex === -1) {\r\n            evaluated = this.checkNumericRight(-1, -1);\r\n            evaluatedLeft = evaluated;\r\n          }\r\n          else {\r\n            if (delimeterRealIndex > 0) {\r\n              this._newvalue = this._newvalue.substr(0, delimeterRealIndex);\r\n            }\r\n            else {\r\n              this._newvalue = \"0\";\r\n            }\r\n            evaluated = this.checkNumericRight(-1, -1);\r\n            evaluatedLeft = evaluated;\r\n          }\r\n        }\r\n      }\r\n\r\n      if ((evaluatedRight.length === 0 && evaluatedLeft.length === 0) || (evaluated.length === 0 && this._newvalue.length > 0)) {\r\n        // space|nothing was inserted  -> use default value\r\n        let ctrl: MgControlBase;\r\n        ctrl = this._valDet.getControl();\r\n\r\n        let field: GuiFieldBase = ctrl.getField();\r\n        let defValue: string = field.getDefaultValue(); // inner value inserted\r\n        let dispDefValue: any = null;\r\n\r\n        if (field.isNullDefault()) {\r\n          this._valDet.setNull(true);\r\n          dispDefValue = field.getNullDisplay();\r\n        }\r\n        if (dispDefValue == null)\r\n          dispDefValue = DisplayConvertor.Instance.mg2disp(defValue, this._valDet.getRange(), this._valDet.getPIC(), true, field.getTask().getCompIdx(), false);\r\n\r\n      }\r\n\r\n      // check if the digit before the delimiter do not exceed the pic wholes.\r\n      let wholeDigitdiff: number = this.digitsBeforeDelimeter(evaluated, 0, this._decimal) - this._valDet.getPIC().getWholes();\r\n      // if they do, check if the exceeding chars are the pad chars. if so, there is no error.\r\n      if (wholeDigitdiff > 0) {\r\n        let padCharOnly: boolean = false;\r\n        // is there a pad, check it. no pad is a certain error.\r\n        if (this._valDet.getIsPadFill()) {\r\n          padCharOnly = true;\r\n          for (let i: number = 0; i < wholeDigitdiff && padCharOnly; i++)\r\n            // if the char is not the pad, then this is an error.\r\n            if (evaluated[i] !== this._valDet.getPadFillChar())\r\n              padCharOnly = false;\r\n        }\r\n\r\n        if (!padCharOnly)\r\n          throw new WrongFormatException(MsgInterface.EDT_ERR_STR_1);\r\n      }\r\n\r\n\r\n      if (this._valDet.getIsNegative() && (this._newvalue.trim().startsWith(\"-\") || (this._valDet.getNegativeSignPref().length !== 0 && this._newvalue.trim().startsWith(this._valDet.getNegativeSignPref())))) {\r\n        evaluated = \"-\" + evaluated;\r\n      }\r\n\r\n      // from this point have evaluated string - the value (without mask) of the control\r\n      // needed to be inserted to the picture\r\n      evaluated = DisplayConvertor.Instance.disp2mg(this._newvalue, this._valDet.getPIC(), this._valDet.getControl().getForm().getTask().getCompIdx(), BlobType.CONTENT_TYPE_UNKNOWN);\r\n      evaluated = DisplayConvertor.Instance.mg2disp(evaluated, \"\", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), true);\r\n\r\n      // in order check if user has entered a blank value , trim and then check it's length.\r\n      let tempDispVal: string = StrUtil.ltrim(evaluated);\r\n      if (tempDispVal.length === 0 && this._valDet.getPIC().zeroFill() && this._valDet.getPIC().getZeroPad() === ' ')\r\n        evaluated = \"0\";\r\n    }\r\n    else {\r\n\r\n      // from this point have evaluated string - the value (without mask) of the control\r\n      // needed to be inserted to the picture\r\n      evaluated = DisplayConvertor.Instance.disp2mg(this._newvalue, this._valDet.getPIC(), this._valDet.getControl().getForm().getTask().getCompIdx(), BlobType.CONTENT_TYPE_UNKNOWN);\r\n      evaluated = DisplayConvertor.Instance.mg2disp(evaluated, \"\", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), true);\r\n\r\n    }\r\n    // Insert the number to range\r\n    if (this._valDet.getContinuousRangeValues() != null || this._valDet.getDiscreteRangeValues() != null)\r\n    {\r\n      this._newvalue = evaluated;\r\n      evaluated = this.fillNumericByRange();\r\n    }\r\n    return evaluated;\r\n  }\r\n\r\n  /// <summary>Check validity of numerical picture from found 'delimeter' to left.\r\n  /// <-.\r\n  /// </summary>\r\n  /// <param name=\"delimeterPictIndex\">found delimeter in the picture</param>\r\n  /// <param name=\"delimeterRealIndex\">found delimeter in the inserted by user new value</param>\r\n  private checkNumericLeft(delimeterPictIndex: number, delimeterRealIndex: number): string {\r\n    let buffer: StringBuilder = new StringBuilder();\r\n    let RealIndex: number = delimeterRealIndex - 1;\r\n    let PictIndex: number;\r\n    let isFound: boolean;\r\n\r\n    for (PictIndex = delimeterPictIndex - 1; PictIndex >= 0 && RealIndex >= 0; PictIndex--)\r\n    {\r\n      if (this._pictureEnable[PictIndex] === '1')\r\n      {\r\n        let tmpstorage: number = RealIndex;\r\n        isFound = false;\r\n\r\n        for (; RealIndex >= 0; RealIndex--)\r\n        {\r\n          if (this._pictureReal[PictIndex] === this._newvalue[RealIndex])\r\n          {\r\n            isFound = true;\r\n            RealIndex--;\r\n            break;\r\n          }\r\n        }\r\n\r\n        if (!isFound)\r\n          RealIndex = tmpstorage;\r\n\r\n        buffer.Append(this._pictureReal[PictIndex]);\r\n      }\r\n      // can insert only number\r\n      else\r\n      {\r\n        for (; RealIndex >= 0; RealIndex--)\r\n        {\r\n          if (UtilStrByteMode.isDigit(this._newvalue[RealIndex]))\r\n          {\r\n            buffer.Append(this._newvalue[RealIndex]);\r\n            RealIndex--;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (RealIndex < 0 && PictIndex >= 0)\r\n    // try to add unwritable\r\n      for (; PictIndex >= 0; PictIndex--)\r\n      {\r\n        if (this._pictureEnable[PictIndex] === '1')\r\n          buffer.Append(this._pictureReal[PictIndex]);\r\n        else\r\n        {\r\n          // only from left need PadFill\r\n          if (this._valDet.getIsPadFill())\r\n            buffer.Append(this._valDet.getPadFillChar());\r\n        }\r\n      }\r\n\r\n    return StrUtil.ReverseString(buffer).ToString();\r\n  }\r\n\r\n  /// <summary>Check validity of numerical picture from found 'delimeter' to right.\r\n  /// .->\r\n  /// </summary>\r\n  /// <param name=\"delimeterPictIndex\">found delimeter in the picture</param>\r\n  /// <param name=\"delimeterRealIndex\">found delimeter in the inserted by user new value</param>\r\n  private checkNumericRight(delimeterPictIndex: number, delimeterRealIndex: number): string {\r\n    let buffer: StringBuilder = new StringBuilder();\r\n    let RealIndex: number = delimeterRealIndex + 1;\r\n    let PictIndex: number;\r\n    let pic: PIC = this._valDet.getPIC();\r\n\r\n    for (PictIndex = delimeterPictIndex + 1; PictIndex < this._pictureEnable.length && RealIndex < this._newvalue.length; PictIndex++)\r\n    {\r\n      if (this._pictureEnable[PictIndex] === '1')\r\n      {\r\n        if (RealIndex < PictIndex)\r\n          RealIndex = PictIndex;\r\n\r\n        buffer.Append(this._pictureReal[PictIndex]);\r\n      }\r\n      // can insert only number\r\n      else\r\n      {\r\n        for (; RealIndex < this._newvalue.length; RealIndex++)\r\n        {\r\n          // Append the digit of actual input data. If it is mask char, skip it.\r\n          if (UtilStrByteMode.isDigit(this._newvalue[RealIndex]) && !pic.picIsMask(RealIndex))\r\n          {\r\n            buffer.Append(this._newvalue[RealIndex]);\r\n            RealIndex++;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // if right part has any input data, then only append unwritable chars\r\n    if (buffer.Length > 0)\r\n    {\r\n      if (RealIndex >= this._newvalue.length && PictIndex < this._pictureReal.length)\r\n      // try to add unwritable\r\n        for (; PictIndex < this._pictureReal.length; PictIndex++)\r\n        {\r\n          if (this._pictureEnable[PictIndex] === '1')\r\n            buffer.Append(this._pictureReal[PictIndex]);\r\n          // else Do nothing\r\n        }\r\n    }\r\n    return buffer.ToString();\r\n  }\r\n\r\n  /// <summary>BUG: 442788\r\n  /// Changing decimal separator in thew pictureReal to value got from Environment\r\n  /// </summary>\r\n  private checkNumericPicture(): void {\r\n    let indexOfDec: number;\r\n    let lastDec: number;\r\n    let maxLength: number;\r\n    let currIndx: number;\r\n    let POINT_DEC: string = \".\"; // used in PICTURE for decimal separator\r\n\r\n    let pic: PIC = this._valDet.getPIC();\r\n\r\n    if (this._pictureReal == null || this._pictureEnable == null || pic.getAttr() !== StorageAttribute.NUMERIC || !pic.withDecimal())\r\n      return;\r\n\r\n    lastDec = this._pictureReal.lastIndexOf(POINT_DEC);\r\n    maxLength = this._pictureEnable.length;\r\n    currIndx = 0;\r\n    while (currIndx < lastDec)\r\n    {\r\n      indexOfDec = this._pictureEnable.indexOf(\"1\", currIndx);\r\n\r\n      if (indexOfDec === -1)\r\n      // not found\r\n        return;\r\n      else\r\n      {\r\n        if (indexOfDec === this._pictureReal.indexOf( POINT_DEC, currIndx))\r\n        // it's real decimal point and not \\. into the picture\r\n        {\r\n          let first: string;\r\n          let second: string;\r\n\r\n          first = second = \"\";\r\n          if (indexOfDec === 0)\r\n          // the point on the first place .###\r\n          {\r\n            if (indexOfDec + 1 < maxLength)\r\n            // only 1 .\r\n              second = this._pictureReal.substr(indexOfDec + 1);\r\n          }\r\n          else if (indexOfDec === maxLength)\r\n          // the point on the last place ###.\r\n          {\r\n            first = this._pictureReal.substr(0 , indexOfDec);\r\n          }\r\n          else\r\n          {\r\n            first = this._pictureReal.substr(0 , indexOfDec);\r\n            second = this._pictureReal.substr(indexOfDec + 1);\r\n          }\r\n          this._pictureReal = first + this._decimal + second;\r\n          break;\r\n        }\r\n        else\r\n        {\r\n          currIndx = ++indexOfDec;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary> Compare newvalue with the range</summary>\r\n  /// <returns> newvalue if it's in the range, oldvalue otherwise</returns>\r\n  private fillNumericByRange(): string {\r\n    let controlPic: PIC = this._valDet.getControl().getPIC();\r\n    let continuousRangeValues: List<string> = this._valDet.getContinuousRangeValues();\r\n    let discreteRangeValues: List<string> = this._valDet.getDiscreteRangeValues();\r\n    this.setValidationFailed(false);\r\n\r\n    let checkedStr: string = this.setNumericValueWithoutPicture(this._newvalue.toString());\r\n\r\n\r\n    if (checkedStr.length === 0) {\r\n      this.printMessage(MsgInterface.STR_RNG_TXT, true);\r\n      return this._oldvalue;\r\n    }\r\n\r\n\r\n      let checkedNum: NUM_TYPE = new NUM_TYPE(this._newvalue.toString(), this._valDet.getControl().getPIC(), 0);\r\n\r\n      if (discreteRangeValues !== null) {\r\n        for (let i: number = 0; i < discreteRangeValues.length; i = i + 1) {\r\n          let rangeItemValue1: NUM_TYPE = new NUM_TYPE(discreteRangeValues.get_Item(i), controlPic, 0);\r\n\r\n          try {\r\n            if (NUM_TYPE.num_cmp(checkedNum, rangeItemValue1) === 0) {\r\n              return this._newvalue;\r\n            }\r\n          }\r\n          catch (ex_CC) {\r\n            // skip non-numeric range values\r\n          }\r\n        }\r\n      }\r\n\r\n      if (continuousRangeValues !== null) {\r\n        for (let i: number = 0; i < continuousRangeValues.length; i = i + 1) {\r\n\r\n          let rangeItemValue1: NUM_TYPE = new NUM_TYPE();\r\n          let rangeItemValue2: NUM_TYPE = new NUM_TYPE();\r\n\r\n          rangeItemValue1.num_4_a_std(continuousRangeValues.get_Item(i++));\r\n          rangeItemValue2.num_4_a_std(continuousRangeValues.get_Item(i));\r\n\r\n          try {\r\n            if (NUM_TYPE.num_cmp(checkedNum, rangeItemValue1) !== -1 && NUM_TYPE.num_cmp(rangeItemValue2, checkedNum) !== -1) {\r\n              return this._newvalue;\r\n            }\r\n          }\r\n          catch (ex_15B) {\r\n            // skip non-numeric range values\r\n          }\r\n        }\r\n      }\r\n      throw new WrongFormatException();\r\n  }\r\n\r\n  /// <summary> returns a numeric value extracted from the beginning of a string\r\n  /// on failure returns NEGATIVE_INFINITY\r\n  /// </summary>\r\n  /// <param name=\"val\">the string to parse</param>\r\n  private getDoubleVal(val: string): number {\r\n\r\n    let dotFound: boolean = false;\r\n    let minusFound: boolean = false;\r\n    let digitFound: boolean = false;\r\n    let endOfNum: boolean = false;\r\n    let i: number = 0;\r\n\r\n    // find the delemeting non numeric character\r\n    for (i = 0; i < val.length && !endOfNum; i++)\r\n    {\r\n      let c: string = val[i];\r\n      if (c >= '0' && c <= '9')\r\n        digitFound = true;\r\n      else\r\n      {\r\n        switch (c)\r\n        {\r\n          case '-':\r\n            if (digitFound || dotFound || minusFound)\r\n              endOfNum = true;\r\n            minusFound = true;\r\n            break;\r\n\r\n          case '.':\r\n            if (dotFound || minusFound && !digitFound)\r\n              endOfNum = true;\r\n            dotFound = true;\r\n            break;\r\n\r\n          case ' ':\r\n            if (digitFound || dotFound || minusFound)\r\n              endOfNum = true;\r\n            break;\r\n\r\n          default:\r\n            endOfNum = true;\r\n            break;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (endOfNum) {\r\n      i = i - 1;\r\n    }\r\n\r\n    if (i > 0) {\r\n      return NNumber.Parse(val.substr(0, i));\r\n    }\r\n\r\n    return -Infinity;\r\n  }\r\n\r\n  /// <summary>set Numeric value Without Picture, filter input from user</summary>\r\n  /// <returns> the pure number, without picture mask</returns>\r\n  private setNumericValueWithoutPicture(val: string): string {\r\n    let checkedStr: StringBuilder = new StringBuilder(val.length);\r\n    let isFirstDecimal: boolean = false;\r\n    let currChar: string;\r\n\r\n    for (let i: number = 0; i < this._pictureReal.length && i < val.length; i++)\r\n    {\r\n      currChar = val[i];\r\n      if (UtilStrByteMode.isDigit(currChar))\r\n        checkedStr.Append(currChar);\r\n      else if (currChar === this._environment.GetDecimal() && !isFirstDecimal)\r\n      {\r\n        checkedStr.Append(NString.ToCharArray(NumberFormatInfo.NumberDecimalSeparator).toString());\r\n        isFirstDecimal = true;\r\n      }\r\n      else if (currChar === '-' && this._valDet.getIsNegative())\r\n        checkedStr.Append(NString.ToCharArray(NumberFormatInfo.NegativeSign).toString());\r\n    }\r\n    if (checkedStr.ToString().length === 0)\r\n    {\r\n      this.printMessage(MsgInterface.STR_ERR_NUM, false);\r\n      this.setValidationFailed(true);\r\n    }\r\n    return checkedStr.ToString();\r\n  }\r\n\r\n  /// <summary> check if newvalue format matches the numeric pic format.</summary>\r\n  /// <returns></returns>\r\n  private checkNumericInDecFormat(): boolean {\r\n\r\n\r\n    let pic: PIC = this._valDet.getPIC();\r\n    let i: number;\r\n    let Dec: number;\r\n    let Whole: number;\r\n    let DecPos: number;\r\n    let decimalChar: string = this._environment.GetDecimal();\r\n\r\n    // Count number of digits and position of decimal point\r\n\r\n    Dec = 0;\r\n    Whole = 0;\r\n    DecPos = -1;\r\n\r\n    for (i = 0; i < this._newvalue.length; i++)\r\n      if (pic.isNumeric(i))\r\n        if (UtilStrByteMode.isDigit(this._newvalue[i]))\r\n        // when dec pos not found, count wholes, if found, count dec.\r\n          if (DecPos >= 0)\r\n            Dec++;\r\n          else\r\n            Whole++;\r\n        else if (this._newvalue[i] === decimalChar)\r\n          DecPos = i;\r\n\r\n    // did we exceed the mask ?\r\n    if (pic.getWholes() < Whole || pic.getDec() < Dec)\r\n      return false;\r\n    else\r\n      return true;\r\n  }\r\n\r\n  /// <summary>check & validate Date field by his old/new value and 2 pictures:\r\n  /// Real and Enable\r\n  /// 1.check if newvalue complete with pictures, otherwise return oldvalue\r\n  /// 2.check if newvalue complete with range\r\n  /// 2.1 complete value, if possible, otherwise  return oldvalue\r\n  /// </summary>\r\n  /// <returns> new value of validated field</returns>\r\n  private checkDateField(): Date {\r\n\r\n    let newDate: Date = (this._newvalue == null ? null : new Date(this._newvalue));\r\n     this.setValidationFailed(false);\r\n\r\n    if (this._valDet.getControl().isDateZero(this._newvalue)) {\r\n      // get default value of the field\r\n      let defaultMgValue: string = this._valDet.getControl().getField().getDefaultValue();\r\n\r\n      newDate = DisplayConvertor.Instance.mg2disp(defaultMgValue, \"\", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), false);\r\n    }\r\n    else\r\n    {\r\n      // range date\r\n      if (this._valDet.getContinuousRangeValues() != null || this._valDet.getDiscreteRangeValues() != null)\r\n        newDate = this.fillDateByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues(), this._newvalue);\r\n    }\r\n    return newDate;\r\n\r\n  }\r\n\r\n  /// <summary>Add found in newvalue numbers(2 or 3 letters) to buffer and return\r\n  /// last found number index\r\n  /// </summary>\r\n  /// <param name=\"currValue\">in newvalue</param>\r\n  /// <param name=\"buffer\"></param>\r\n  /// <param name=\"type\">- which type of positional directive, for checking validity</param>\r\n  /// <returns> currValue in newvalue</returns>\r\n  private add2Date(currValue: number, buffer: StringBuilder, type: number): number {\r\n    let start: number = currValue;\r\n    let currAdd: StringBuilder = new StringBuilder(this._newvalue.length);\r\n    let letters: number = 0;\r\n\r\n    switch (type)\r\n    {\r\n      case PICInterface.PIC_DD:\r\n      case PICInterface.PIC_DDDD:\r\n      case PICInterface.PIC_MMD:\r\n      case PICInterface.PIC_YY:\r\n        letters = 2;\r\n        break;\r\n\r\n      case PICInterface.PIC_DDD:\r\n        letters = 3;\r\n        break;\r\n\r\n      case PICInterface.PIC_YYYY:\r\n        letters = 4;\r\n        break;\r\n\r\n      case PICInterface.PIC_W:\r\n        letters = 1;\r\n        break;\r\n\r\n      case PICInterface.PIC_YJ:  // JPN: Japanese date picture support\r\n        letters = 2;\r\n        type = PICInterface.PIC_YY; // PIC_YJ will be handled as PIC_YY in this method.\r\n        break;\r\n    }\r\n\r\n    while (start < this._newvalue.length && !UtilStrByteMode.isDigit(this._newvalue.charAt(start)))\r\n      start++; // find first digit\r\n\r\n\r\n    if (start === this._newvalue.length && (this._newvalue.length === 0 || this._newvalue === \"0\")) {\r\n      for (let nul: number = 0; nul < letters; nul = nul + 1) {\r\n        buffer.Append('0')/*'0'*/;\r\n      }\r\n      return currValue;\r\n    }\r\n    else if (start === this._newvalue.length) {\r\n      this._newvalue = this._newvalue + \"0\";\r\n    }\r\n\r\n    let i: number;\r\n    for (i = start; i < start + letters && i < this._newvalue.length; i++) {\r\n      if (UtilStrByteMode.isDigit(this._newvalue.charAt(i)))\r\n        currAdd.Append(this._newvalue.charAt(i));\r\n      else\r\n        break;\r\n    }\r\n\r\n    if (currAdd.Length === 0) {\r\n      currAdd.Append('0');\r\n    }\r\n\r\n    let add: number = NNumber.Parse(currAdd.ToString());\r\n\r\n    // boundary conditions cases:\r\n    if ((add < 1 && type !== PICInterface.PIC_YYYY && type !== PICInterface.PIC_YY) ||\r\n       (add > 31 && (type === PICInterface.PIC_DD || type ===  PICInterface.PIC_DDDD)) ||\r\n      (add > 12 && type === PICInterface.PIC_MMD) || (add > 7 && type === PICInterface.PIC_W)) {\r\n      throw new WrongFormatException(MsgInterface.STR_ERR_DATE);\r\n    }\r\n\r\n    // than picture is YYYY and inserted 0-2 numbers, use CENTURE value, otherwise add zeros before the year\r\n    if (type === PICInterface.PIC_YYYY && this._environment.GetCentury(this._valDet.getControl().getForm().getTask().getCompIdx()) > 999 && currAdd.Length < 3)\r\n      currAdd = this.checkCentury(add);\r\n\r\n    for (let j: number = 0; j < letters - currAdd.Length; j = j + 1) {\r\n      buffer.Append('0')/*'0'*/;\r\n    }\r\n    buffer.Append(currAdd.ToString());\r\n    return  i;\r\n  }\r\n\r\n  /// <summary>Add found in newvalue letters to buffer and return\r\n  /// last found number index\r\n  /// </summary>\r\n  /// <param name=\"currValue\">in newvalue</param>\r\n  /// <param name=\"letters\">amount of letters to insert to buffer</param>\r\n  /// <param name=\"buffer\"></param>\r\n  /// <returns> currValue in newvalue</returns>\r\n  private addM2Date(currValue: number, letters: number, buffer: StringBuilder, type: number): number {\r\n    let array: string[];\r\n    let result: number;\r\n\r\n    if (type === PICInterface.PIC_MMM || type === PICInterface.PIC_MMD) {\r\n      if (this.hebrew) {\r\n        array = HebrewDate.GetLocalMonths();\r\n      }\r\n      else {\r\n        let messageString: string = Events.GetMessageString(MsgInterface.MONTHS_PTR);\r\n        array = DateUtil.getLocalMonths(messageString);\r\n      }\r\n    }\r\n    else {\r\n      if (type === PICInterface.PIC_WWW || type === PICInterface.PIC_W) {\r\n        if (this.hebrew) {\r\n          array = HebrewDate.GetLocalDows();\r\n        }\r\n        else {\r\n          let dayStr: string = Events.GetMessageString(MsgInterface.DAYS_PTR);\r\n          array = DateUtil.getLocalDays(dayStr);\r\n        }\r\n      }\r\n      else {\r\n        if (type === PICInterface.PIC_BB) { // JPN: Japanese date picture support\r\n          array = UtilDateJpn.getArrayDow();\r\n        }\r\n        else {\r\n          if (type === PICInterface.PIC_JY1 || type === PICInterface.PIC_JY2 || type === PICInterface.PIC_JY4)\r\n          {\r\n            if (this._newvalue.length < currValue + letters) {\r\n              throw new WrongFormatException(MsgInterface.STR_ERR_DATE);\r\n            }\r\n            let text: string = this._newvalue.substr(currValue, letters);\r\n            buffer.Append(text);\r\n            return currValue + text.length;\r\n          }\r\n          else\r\n          {\r\n            return currValue + letters;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (this._newvalue.length < currValue) {\r\n      currValue = this._newvalue.length;\r\n    }\r\n    let max: number = this.getMonthOrWeek(this._newvalue.substr(currValue), letters, type);\r\n\r\n    if (array[max].trim().length >= letters) {\r\n      buffer.Append(array[max].trim().substr(0, letters));\r\n    }\r\n    else {\r\n      buffer.Append(array[max].trim());\r\n      for (let i: number = letters - array[max].trim().length; i > 0; i = i - 1) {\r\n        buffer.Append(' ')/*' '*/;\r\n      }\r\n    }\r\n    return currValue + letters;\r\n  }\r\n\r\n  /// <summary>get end index of every numeric block in the mask from mask[currValue]</summary>\r\n  /// <returns> end of numeric block in newValue</returns>\r\n  private getEndOfNumericBlock(currValue: number): number {\r\n    while (currValue < this._newvalue.length && !UtilStrByteMode.isDigit(this._newvalue.charAt(currValue))) {\r\n      currValue = currValue + 1;\r\n    }\r\n    return currValue;\r\n  }\r\n\r\n  /// <summary>added suffix to relevant number of the day</summary>\r\n  private addDateSuffix(last: string): string {\r\n    let thenumber: number = NNumber.Parse(last);\r\n    if (thenumber === 1 || thenumber === 21 || thenumber === 31)\r\n      return \"st\";\r\n    else if (thenumber === 2 || thenumber === 22)\r\n      return \"nd\";\r\n    else if (thenumber === 3 || thenumber === 23)\r\n      return \"rd\";\r\n    return \"th\";\r\n  }\r\n\r\n  /// <summary>get size of block letters of type 'type', which start at 'start'</summary>\r\n  private getSizeOfBlock(start: number, type: number): number {\r\n    let letters: number = start + 1;\r\n    while (letters < this._picture.length && this._picture.charCodeAt(letters) === type)\r\n    letters++;\r\n    return letters - start;\r\n  }\r\n\r\n  /// <summary>get String part/full name of month/day of week</summary>\r\n  /// <param name=\"month\">part/full name of month/day of week</param>\r\n  /// <param name=\"max\">of possible letters in month/day of week, size of block in picture of the control</param>\r\n  /// <param name=\"type:\">PIC_  week|month</param>\r\n  /// <returns> number of month 1-12, or day of week 1-7</returns>\r\n  private getMonthOrWeek(month_str: string, letters: number, type: number): number {\r\n    let array: string[];\r\n\r\n    if (type === PICInterface.PIC_MMM || type === PICInterface.PIC_MMD) {\r\n      // Month\r\n        if (this.hebrew)\r\n          array = HebrewDate.GetLocalMonths();\r\n        else\r\n        {\r\n          let monthStr: String = Events.GetMessageString(MsgInterface.MONTHS_PTR);\r\n          array = DateUtil.getLocalMonths(monthStr.toString());\r\n        }\r\n      }\r\n    else if (type === PICInterface.PIC_WWW || type === PICInterface.PIC_W)\r\n      // Week\r\n      {\r\n        if (this.hebrew)\r\n          array = HebrewDate.GetLocalDows();\r\n        else\r\n        {\r\n          let dayStr: String = Events.GetMessageString(MsgInterface.DAYS_PTR);\r\n          array = DateUtil.getLocalDays(dayStr.toString());\r\n        }\r\n      }\r\n      else if (type === PICInterface.PIC_BB)\r\n      // JPN: Japanese date picture support\r\n      {\r\n        array = UtilDateJpn.getArrayDow();\r\n      }\r\n      else\r\n      {\r\n        return 1; // only week or month possible -> diffault 1.\r\n      }\r\n\r\n    if (letters > month_str.length)\r\n    // cut letter if it's  end of string\r\n      letters = month_str.length;\r\n\r\n    if (this.hebrew)\r\n    {\r\n      let hstr: string = NString.TrimStart(month_str).substr(0, letters).trim();\r\n\r\n      for (let i: number = 1; i < array.length; i++)\r\n      // start checking from 1st member, because 0 = \"\"\r\n      {\r\n        if (array[i].trim() === hstr)\r\n        {\r\n          if (i === 14)\r\n            i = 6;\r\n          return i;\r\n        }\r\n      }\r\n      return 0;\r\n    }\r\n\r\n    try {\r\n        // the number inserted and not string -> find mounth/day of week by number 1-12|1-7\r\n\r\n        let str: string = month_str.substr(0, letters).trim();\r\n        let numBuffer: StringBuilder = new StringBuilder(str.length);\r\n\r\n        for (let i: number = 0; i < str.length; i++)\r\n        {\r\n          if (UtilStrByteMode.isDigit(str[i]))\r\n            numBuffer.Append(str[i]);\r\n          else\r\n            break;\r\n        }\r\n\r\n        let theNumber: number = NNumber.Parse(numBuffer.ToString());\r\n        if (theNumber < 1)\r\n          return 1;\r\n        if (type === PICInterface.PIC_MMM || type === PICInterface.PIC_MMD)\r\n        {\r\n          if (theNumber > 12)\r\n            return 12;\r\n        }\r\n        else if (type === PICInterface.PIC_WWW || type === PICInterface.PIC_W || type === PICInterface.PIC_BB)\r\n        {\r\n          // JPN: Japanese date picture support\r\n          if (theNumber > 7)\r\n            return 7;\r\n        }\r\n        return theNumber;\r\n        }\r\n    catch (ex_21A) {\r\n          // doNothing_StringInserted\r\n      }\r\n\r\n    // inserted string - name of month|day of week ->try identyfy it\r\n    let found: number[] = new Array<number>(array.length);\r\n    let from: number;\r\n    let max: number = -1; // number of found month/day of week\r\n\r\n\r\n    for (let tmp: number = 1; tmp < array.length; tmp++)\r\n    // start checking from 1st member, because 0 = \"\"\r\n    {\r\n      found[tmp] = 0;\r\n      from = 0;\r\n      for (let i: number = 0; i < array[tmp].length && from < month_str.length && i < letters; i++, from++)\r\n      {\r\n        if (array[tmp].toLowerCase()[i] === month_str.toLowerCase()[from])\r\n          found[tmp]++;\r\n        else\r\n          break;\r\n      }\r\n\r\n      if (from === letters || from === array[tmp].length)\r\n      // all letters found\r\n      {\r\n        max = tmp;\r\n        break;\r\n      }\r\n    }\r\n\r\n    if (max === -1)\r\n      max = this.findMax(found);\r\n    return max;\r\n\r\n  }\r\n\r\n  /// <summary>is numeric data allowed in date\r\n  /// return true if it is allowed, otherwise false</summary>\r\n  private isNumberAllowedInDate(): boolean {\r\n    for (let i: number = 0; i < this._picture.length; i++)\r\n    {\r\n      if (this.isDatePositionalNumericDirective(this._picture[i]))\r\n        return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>find if all numbers of the new user inserted value are 0\r\n  /// return true if all numbers in the input are 0, otherwise true</summary>\r\n  private isAllNumbers0(): boolean {\r\n    let currChr: string;\r\n    for (let i: number = 0; i < this._newvalue.length; i++)\r\n    {\r\n      currChr = this._newvalue[i];\r\n\r\n      if (UtilStrByteMode.isDigit(currChr) && currChr !== '0')\r\n        return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /// <summary>check validity of Year for YYYY part of the mask</summary>\r\n  /// <param name=\"yearIn\">inserted by user</param>\r\n  /// <returns> calculated by environment.century right value</returns>\r\n  private checkCentury(yearIn: number): StringBuilder {\r\n    let outVal: number;\r\n    let start_century: number = this._environment.GetCentury(this._valDet.getControl().getForm().getTask().getCompIdx());\r\n    let century: number = Math.floor(start_century / 100);\r\n    let years: number = start_century % 100;\r\n    if (yearIn >= years && yearIn !== 0)\r\n      outVal = (century * 100 + yearIn);\r\n    else\r\n      outVal = ((++century) * 100 + yearIn);\r\n\r\n    return new StringBuilder(outVal.toString());\r\n  }\r\n\r\n  /// <summary>check if the date legal for picture range, used for validation date 0</summary>\r\n  /// <param name=\"ContinuousRange\"></param>\r\n  /// <param name=\"DiscreteRange\"></param>\r\n  /// <param name=\"date\">integer - magic date number of days from 01.01.0000</param>\r\n  private isDateLegal4Range(ContinuousRange: List<string>, DiscreteRange: List<string>, currDate: number): boolean {\r\n\r\n    let pic: PIC = this._valDet.getPIC();\r\n    let i: number;\r\n    let downDate: number;\r\n    let topDate: number;\r\n\r\n    if (ContinuousRange != null)\r\n    {\r\n      for (i = 0; i < ContinuousRange.length - 1; i++)\r\n      {\r\n        downDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());\r\n        topDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(++i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());\r\n        if (currDate >= downDate && currDate <= topDate)\r\n          return true;\r\n      }\r\n    }\r\n\r\n    if (DiscreteRange != null)\r\n    {\r\n      for (i = 0; i < DiscreteRange.length; i++)\r\n      {\r\n        if (currDate === DisplayConvertor.Instance.a_2_date_pic(DiscreteRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx()))\r\n          return true;\r\n      }\r\n    }\r\n    // the date is not in the range\r\n    // return false;\r\n    throw new WrongFormatException();\r\n  }\r\n\r\n  /// <summary>check and fill DATE type by range</summary>\r\n  private fillDateByRange(ContinuousRange: List<string>, DiscreteRange: List<string>, buffer: Date): Date {\r\n    let pic: PIC = this._valDet.getPIC();\r\n    let i: number;\r\n    let downDate: number;\r\n    let topDate: number;\r\n\r\n    let currDate = DisplayConvertor.Instance.fromNativeDateToMgDateNumber(buffer, pic);\r\n\r\n    this.setValidationFailed(false);\r\n    if (ContinuousRange != null) {\r\n      for (i = 0; i < ContinuousRange.length - 1; i++) {\r\n        downDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());\r\n        topDate = DisplayConvertor.Instance.a_2_date_pic(ContinuousRange.get_Item(++i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx());\r\n        if (currDate >= downDate && currDate <= topDate)\r\n          return new Date(buffer);\r\n      }\r\n    }\r\n\r\n    if (DiscreteRange != null) {\r\n      for (i = 0; i < DiscreteRange.length; i++) {\r\n        if (currDate === DisplayConvertor.Instance.a_2_date_pic(DiscreteRange.get_Item(i), pic, pic.getMask(), this._valDet.getControl().getForm().getTask().getCompIdx())) {\r\n          return new Date(buffer);\r\n        }\r\n      }\r\n    }\r\n    // the date is not in the range\r\n    throw new WrongFormatException();\r\n\r\n  }\r\n\r\n  /// <summary>check if day suitable (not bigger than max) for Year and Month</summary>\r\n  /// <param name=\"date\">user inserted string</param>\r\n  /// <param name=\"isDoy\">is picture of needed day is DDD - day of year</param>\r\n  private checkDay(date: string, isDoy: boolean): StringBuilder {\r\n\r\n    let day: number = this.getDateElement(date, DateElement.DAY);\r\n    if (day < 29 && !isDoy)\r\n      return new StringBuilder(date);\r\n\r\n    let year: number = this.getDateElement(date, DateElement.YEAR);\r\n\r\n    if (!isDoy)\r\n    {\r\n      if (year.toString().length < 3)\r\n        year = NNumber.Parse(this.checkCentury(year).ToString());\r\n\r\n      if (this._environment.GetDateMode(this._valDet.getControl().getForm().getTask().getCompIdx()) === 'B')\r\n        year -= PICInterface.DATE_BUDDHIST_GAP;\r\n\r\n      let month: number = this.getDateElement(date, DateElement.MONTH);\r\n\r\n      // if day not consistained to year & month - change day\r\n      let dayMax: number = this.getMaxDayInMonth(year, month);\r\n      if (day > dayMax)\r\n      {\r\n        throw new WrongFormatException(MsgInterface.STR_ERR_DATE);\r\n      }\r\n    }\r\n    else\r\n    {\r\n      // if month not consistained to day(DDD) - change month\r\n      let monthReal: number = this.getMonthByDay(year, day);\r\n\r\n      if (monthReal < 1 || monthReal > 12)\r\n        throw new WrongFormatException(MsgInterface.STR_ERR_DATE);\r\n    }\r\n\r\n    return new StringBuilder(date);\r\n  }\r\n\r\n  /// <summary>check if day of week suitable (right) for Year, Month and Day</summary>\r\n  /// <param name=\"date\">user inserted string</param>\r\n  private checkWeek(date: string): StringBuilder {\r\n\r\n    let dow: number = this.getDateElement(date, DateElement.DOW);\r\n\r\n    let breakParams: DateBreakParams = DisplayConvertor.Instance.getNewDateBreakParams();\r\n\r\n    let dateMagic: number = DisplayConvertor.Instance.a_2_date(date, this._picture, this._valDet.getControl().getForm().getTask().getCompIdx());\r\n\r\n    DisplayConvertor.Instance.date_break_datemode(breakParams, dateMagic, true, this._valDet.getControl().getForm().getTask().getCompIdx());\r\n\r\n    let dowReal: number = breakParams.dow;\r\n    if (dowReal !== dowReal)\r\n      date = this.changeDow(date, dowReal);\r\n\r\n    return new StringBuilder(date);\r\n  }\r\n\r\n\r\n  // JPN: Japanese date picture support\r\n  /// <summary>check if the combination of Japanese era and year is valid.</summary>\r\n  /// <param name=\"strDate\">user inserted string</param>\r\n  /// <returns> date string of properly Japanese era</returns>\r\n  private checkJpnEraYear(strDate: string): StringBuilder {\r\n\r\n    let breakParams: DateBreakParams = DisplayConvertor.Instance.getNewDateBreakParams();\r\n    let dateMagic: number = DisplayConvertor.Instance.a_2_date(strDate, this._picture, this._valDet.getControl().getForm().getTask().getCompIdx());\r\n\r\n    DisplayConvertor.Instance.date_break_datemode(breakParams, dateMagic, true, this._valDet.getControl().getForm().getTask().getCompIdx());\r\n\r\n    let intYearAD: number = breakParams.year;\r\n    let intDoy: number = breakParams.doy;\r\n\r\n    // get the name and a year of the era\r\n    let strEraAlpha: string;\r\n    let strEraKanji: string;\r\n\r\n    strEraAlpha = UtilDateJpn.getInstance().date_jpn_yr_2_a(intYearAD, intDoy, false);\r\n    strEraKanji = UtilDateJpn.getInstance().date_jpn_yr_2_a(intYearAD, intDoy, true);\r\n\r\n    let strYearJpnEra: StringBuilder = new StringBuilder();\r\n    let num: number = UtilDateJpn.getInstance().date_jpn_year_ofs(intYearAD, intDoy);\r\n    if (num <= 0) {\r\n      throw new WrongFormatException(MsgInterface.STR_ERR_DATE);\r\n    }\r\n    if (num <= 9) {\r\n      strYearJpnEra.Append(\"0\");\r\n    }\r\n    strYearJpnEra.Append(num.toString());\r\n\r\n    // build a properly year of the era\r\n\r\n    // A DBCS character in \"str\" consumes two characters in \"mask\".\r\n    // If \"str\" contains DBCS, the position of \"mask\" has to skip next index.\r\n    // This variable indicates the number of skipped indexes.\r\n    let intPicIdxOfs: number = 0;\r\n    for (let intCnt: number = 0; intCnt + intPicIdxOfs < this._picture.length; intCnt++)\r\n    {\r\n      switch (this._picture.charCodeAt(intCnt + intPicIdxOfs))\r\n      {\r\n        case (PICInterface.PIC_JY1):\r\n          strDate = UtilStrByteMode.repC(strDate, strEraAlpha, intCnt + 1, 1);\r\n          break;\r\n\r\n        case (PICInterface.PIC_JY2):\r\n          strDate = UtilStrByteMode.repC(strDate, strEraKanji, intCnt + 1, 1);\r\n          intPicIdxOfs++; // PIC_JY2 consumes 2 characters of picture (1 more than strDate)\r\n          break;\r\n\r\n        case (PICInterface.PIC_JY4):\r\n          strDate = UtilStrByteMode.repC(strDate, strEraKanji, intCnt + 1, 2);\r\n          intCnt++; // PIC_JY4 consumes 2 characters of strDate\r\n          intPicIdxOfs += 2; // PIC_JY4 consumes 4 characters of picture (2 more than strDate)\r\n          break;\r\n\r\n        case (PICInterface.PIC_YJ):\r\n          strDate = UtilStrByteMode.repC(strDate, strYearJpnEra.toString(), intCnt + 1, 2);\r\n          intCnt++; // PIC_YJ consumes 2 characters of strDate\r\n          break;\r\n\r\n        default:\r\n          if (intCnt < strDate.length)\r\n          {\r\n            // if \"strDate\" contains DBCS, the next index of \"picture\" has to be skipped.\r\n            if (UtilStrByteMode.isHalfWidth(strDate[intCnt]) === false && UtilStrByteMode.isHalfWidth(this._picture[intCnt + intPicIdxOfs]) === true)\r\n              intPicIdxOfs++;\r\n          }\r\n          break;\r\n\r\n      }\r\n    }\r\n    return new StringBuilder(strDate);\r\n  }\r\n\r\n  /// <summary>get max number of day in month</summary>\r\n  /// <param name=\"year\"></param>\r\n  /// <param name=\"month\"></param>\r\n  /// <returns> max days [28-31] number</returns>\r\n  private getMaxDayInMonth(year: number, month: number): number {\r\n    let array: number[] = [\r\n      0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31\r\n    ];\r\n    let leapyear: boolean = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\r\n\r\n    if (leapyear && month === 2)\r\n      return array[month] + 1;\r\n\r\n     return array[month];\r\n  }\r\n\r\n  /// <summary>get month for day, than day have mask DDD</summary>\r\n  /// <param name=\"year\"></param>\r\n  /// <param name=\"day\">[0-365]</param>\r\n  /// <returns> number of month</returns>\r\n  private getMonthByDay(year: number, day: number): number {\r\n    let i: number;\r\n    let LeapYear: boolean;\r\n\r\n    LeapYear = (year % 4 === 0) && ((year % 100 !== 0) || (year % 400 === 0));\r\n\r\n    for (i = 0; i < PICInterface.date_day_tab.length; i++)\r\n    {\r\n      if (!LeapYear)\r\n      {\r\n        if (PICInterface.date_day_tab[i] >= day)\r\n          return i;\r\n      }\r\n      // is Leap Year\r\n      else\r\n      {\r\n        if (i < 3)\r\n        {\r\n          if (PICInterface.date_day_tab[i] >= day)\r\n            return i;\r\n        }\r\n        // add 1 day after second month\r\n        else\r\n        {\r\n          if (PICInterface.date_day_tab[i] + 1 >= day)\r\n            return i;\r\n        }\r\n      }\r\n    } // for loop\r\n    return i; // the function cann't came to the statement anytime\r\n  }\r\n\r\n  /// </summary>get Year|Month|Day|Dow of date\r\n  /// <param name=\"date\">date</param>\r\n  /// <param name=\"element\">required date element (year/month/day/dow) </param>\r\n  /// <returns>Year|Month|Day|Dow of date</returns>\r\n  private getDateElement(date: string, element: DateElement): number {\r\n    let buffer: String = null;\r\n    let letters: number = 0;\r\n    let exitLoop: boolean = false;\r\n    let picWeekType: number = PICInterface.PIC_WWW; // JPN: Japanese date picture support\r\n    let isJpnEraYear: boolean = false; // JPN: Japanese date picture support\r\n    let era_year: number = 0;\r\n\r\n    // A DBCS character in \"date\" consumes two characters in \"picture\".\r\n    // If \"date\" contains DBCS, the position of \"picture\" has to skip next index.\r\n    // This variable indicates the number of skipped indexes.\r\n    let intPicIdxOfs: number = 0; // JPN: Japanese date picture support\r\n\r\n    let minLen: number = 0;\r\n\r\n    if (UtilStrByteMode.isLocaleDefLangJPN())\r\n      minLen = UtilStrByteMode.getMinLenPicture(date, this._picture);\r\n    else\r\n      minLen = Math.min(date.length, this._picture.length);\r\n\r\n    for (let i: number = 0; i + intPicIdxOfs < minLen && !exitLoop; i++)\r\n    {\r\n      if (this.isDataPositionalDirective(this._picture[i + intPicIdxOfs]))\r\n      {\r\n        switch (this._picture.charCodeAt(i + intPicIdxOfs))\r\n        {\r\n\r\n        case PICInterface.PIC_DD:\r\n          if (element === DateElement.DAY)\r\n          {\r\n            buffer = date.substr(i, 2);\r\n            exitLoop = true;\r\n            break;\r\n          }\r\n          i++;\r\n          break;\r\n\r\n        case PICInterface.PIC_DDD:\r\n          if (element === DateElement.DAY)\r\n          {\r\n            buffer = date.substr(i, 3);\r\n            exitLoop = true;\r\n            break;\r\n          }\r\n          i += 2;\r\n          break;\r\n\r\n        case PICInterface.PIC_DDDD:\r\n          if (element === DateElement.DAY)\r\n          {\r\n            buffer = date.substr(i, 2); // not +4 need not suffix of 'nd', 'rd', 'st'\r\n            exitLoop = true;\r\n          }\r\n          i += 3;\r\n          break;\r\n\r\n        case PICInterface.PIC_MMD:\r\n          if (element === DateElement.MONTH)\r\n          {\r\n            buffer = date.substr(i, 2);\r\n            exitLoop = true;\r\n          }\r\n          i++;\r\n          break;\r\n\r\n        case PICInterface.PIC_MMM:\r\n          // get size of PIC_MMM block\r\n          letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_MMM);\r\n          if (element === DateElement.MONTH)\r\n          {\r\n            buffer = date.substr(i, letters);\r\n            exitLoop = true;\r\n            break;\r\n          }\r\n          i += letters - 1;\r\n          letters = 0;\r\n          break;\r\n\r\n        case PICInterface.PIC_YY:\r\n          if (element === DateElement.YEAR)\r\n          {\r\n            buffer = date.substr(i, 2);\r\n            exitLoop = true;\r\n          }\r\n          i++;\r\n          break;\r\n\r\n        case PICInterface.PIC_YYYY:\r\n          if (element === DateElement.YEAR)\r\n          {\r\n            buffer = date.substr(i, 4);\r\n            exitLoop = true;\r\n          }\r\n          i += 3;\r\n          break;\r\n\r\n        case PICInterface.PIC_W:\r\n          if (element === DateElement.DOW)\r\n          {\r\n            buffer = date.substr(i, 1);\r\n            exitLoop = true;\r\n          }\r\n          break;\r\n\r\n        case PICInterface.PIC_WWW:\r\n          letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_WWW);\r\n          if (element === DateElement.DOW)\r\n          {\r\n            buffer = date.substr(i, letters);\r\n            exitLoop = true;\r\n            break;\r\n          }\r\n          i += letters - 1;\r\n          letters = 0;\r\n          break;\r\n\r\n        case PICInterface.PIC_HYYYYY:\r\n        case PICInterface.PIC_HL:\r\n        case PICInterface.PIC_HDD:\r\n          // not implemented for hebrew yet\r\n          break;\r\n\r\n        case PICInterface.PIC_BB:  // JPN: Japanese date picture support\r\n          letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_BB);\r\n\r\n          if (i + Math.floor(letters / 2) < date.length)\r\n          {\r\n            buffer = date.substr(i, Math.floor(letters / 2));\r\n            // if date contains DBCS, some indexes of picture have to be skipped.\r\n            intPicIdxOfs += letters - buffer.length;\r\n          }\r\n\r\n          if (element === DateElement.DOW)\r\n          {\r\n            exitLoop = true;\r\n            picWeekType = PICInterface.PIC_BB;\r\n          }\r\n          else\r\n          {\r\n            buffer = null;\r\n          }\r\n\r\n          i += letters - 1;\r\n          break;\r\n\r\n        case PICInterface.PIC_JY1:  // JPN: Japanese date picture support\r\n          isJpnEraYear = true;\r\n          break;\r\n\r\n        case PICInterface.PIC_JY2:  // JPN: Japanese date picture support\r\n          isJpnEraYear = true;\r\n          intPicIdxOfs++;\r\n          break;\r\n\r\n        case PICInterface.PIC_JY4:  // JPN: Japanese date picture support\r\n          isJpnEraYear = true;\r\n          intPicIdxOfs += 2;\r\n          i++;\r\n          break;\r\n\r\n        case PICInterface.PIC_YJ:  // JPN: Japanese date picture support\r\n          if (element === DateElement.YEAR)\r\n          {\r\n            buffer = date.substr(i, 2);\r\n            exitLoop = true;\r\n          }\r\n          i++;\r\n          break;\r\n        } // switch of positional directives\r\n        } // if of positional directives\r\n    } // for loop in picture\r\n\r\n    if (buffer == null)\r\n    {\r\n      if (element === DateElement.YEAR)\r\n        return DateTime.Now.Year;\r\n      else\r\n        return 1;\r\n    }\r\n\r\n    buffer = buffer.trim();\r\n\r\n    if (letters > 0)\r\n    // it's PIC_WWW or PIC_MMM\r\n    {\r\n      if (element === DateElement.MONTH)\r\n        letters = this.getMonthOrWeek(buffer.toString(), letters, PICInterface.PIC_MMM);\r\n      else if (element === DateElement.DOW)\r\n        letters = this.getMonthOrWeek(buffer.toString(), letters, picWeekType);\r\n    }\r\n    else\r\n    {\r\n      while (buffer.toString().startsWith(\"0\") || buffer.toString().startsWith(\" \"))\r\n        buffer = buffer.toString().substr(1);\r\n      if (buffer.length === 0)\r\n        letters = 0;\r\n      else\r\n        letters = NNumber.Parse(buffer.toString());\r\n    }\r\n\r\n    if (element === DateElement.YEAR && isJpnEraYear)\r\n    {\r\n      // get the start year of the era\r\n      era_year = UtilDateJpn.getInstance().getStartYearOfEra(date, this._picture);\r\n      if (era_year === 0)\r\n        return 0;\r\n      letters += era_year - 1;\r\n    }\r\n\r\n    return letters;\r\n  }\r\n\r\n  /// <summary>change day number in date field to dayMax</summary>\r\n  /// <param name=\"date\">to change day into</param>\r\n  /// <param name=\"dayMax\">the new day value</param>\r\n  private changeDow(date: string, dow: number): string {\r\n    let isDate: boolean = false;\r\n    let letters: number;\r\n    let startPart: string;\r\n    let finishPart: string;\r\n    let number1: string;\r\n\r\n    number1 = \"\" + dow; // \" \"\r\n\r\n    // A DBCS character in \"date\" consumes two characters in \"picture\".\r\n    // If \"date\" contains DBCS, the position of \"picture\" has to skip next index.\r\n    // This variable indicates the number of skipped indexes. (JPN: DBCS support)\r\n    let intPicIdxOfs: number = 0;\r\n\r\n    for (let i: number = 0; i + intPicIdxOfs < this._picture.length && !isDate; i++)\r\n    {\r\n      if (this.isDataPositionalDirective(this._picture[i + intPicIdxOfs]))\r\n      {\r\n        switch (this._picture.charCodeAt(i + intPicIdxOfs))\r\n        {\r\n\r\n        case PICInterface.PIC_W:\r\n          startPart = date.substr(0, i);\r\n          finishPart = date.substr(i + 1);\r\n          date = startPart + number1 + finishPart;\r\n          isDate = true;\r\n          break;\r\n\r\n        case PICInterface.PIC_WWW:\r\n          letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_WWW);\r\n          startPart = date.substr(0, i);\r\n          finishPart = date.substr(i + letters);\r\n          let dayStr: string = Events.GetMessageString(MsgInterface.DAYS_PTR);\r\n          let dayNames: string[] = DateUtil.getLocalDays(dayStr);\r\n          number1 = dayNames[dow];\r\n\r\n          if (number1.length > letters)\r\n            number1 = number1.substr(0, letters);\r\n          else if (number1.length < letters)\r\n            while (number1.length < letters)\r\n              number1 = number1 + ' ';\r\n          date = startPart + number1 + finishPart;\r\n          isDate = true;\r\n          break;\r\n\r\n        case PICInterface.PIC_BB:  // JPN: Japanese date picture support\r\n          letters = this.getSizeOfBlock(i + intPicIdxOfs, PICInterface.PIC_BB);\r\n          // \"letters\" means a number of characters in \"picture\"\r\n\r\n          startPart = date.substr(0, i);\r\n          finishPart = date.substr(i + Math.floor(letters / 2));\r\n          // \"letters / 2\" means a number of characters in \"date\"\r\n\r\n          number1 = UtilDateJpn.getStrDow(dow);\r\n\r\n          if (UtilStrByteMode.lenB(number1) > letters)\r\n            number1 = UtilStrByteMode.leftB(number1, letters);\r\n          else if (UtilStrByteMode.lenB(number1) < letters)\r\n            while (UtilStrByteMode.lenB(number1) < letters)\r\n              number1 = number1 + ' ';\r\n          date = startPart + number1 + finishPart;\r\n          isDate = true;\r\n          break;\r\n\r\n        default:\r\n          if (UtilStrByteMode.isLocaleDefLangDBCS())\r\n          // JPN: DBCS support\r\n          {\r\n            if (i < date.length)\r\n            {\r\n              // if \"date\" contains DBCS, the next index of \"picture\" has to be skipped.\r\n              if (UtilStrByteMode.isHalfWidth(date[i]) === false && UtilStrByteMode.isHalfWidth(this._picture[i + intPicIdxOfs]) === true)\r\n                intPicIdxOfs++;\r\n            }\r\n          }\r\n          break;\r\n\r\n        } // switch\r\n        } // if of positional directives\r\n    }\r\n    return date;\r\n  }\r\n\r\n  /// <summary>check & validate Time field by his old/new value and 2 pictures:\r\n  /// Real and Enable\r\n  /// 1.check if newvalue complete with pictures, otherwise return oldvalue\r\n  /// 2.check if newvalue complete with range\r\n  /// 2.1 complete value, if possible, otherwise  return oldvalue\r\n  /// </summary>\r\n  /// <returns> String - new value of validated field</returns>\r\n  private checkTimeField(): Date {\r\n    let newTime: Date = new Date (this._newvalue);\r\n\r\n\r\n    this.setValidationFailed(false);\r\n\r\n    if (this._valDet.getControl().isDateZero(this._newvalue)) {\r\n      // get default value of the field\r\n      let defaultMgValue: string = this._valDet.getControl().getField().getDefaultValue();\r\n      newTime = DisplayConvertor.Instance.mg2disp(defaultMgValue, \"\", this._valDet.getPIC(), true, this._valDet.getControl().getForm().getTask().getCompIdx(), false);\r\n    }\r\n    else {\r\n\r\n      // range of the time\r\n      if (this._valDet.getContinuousRangeValues() != null || this._valDet.getDiscreteRangeValues() != null)\r\n        newTime = this.fillTimeByRange(this._valDet.getContinuousRangeValues(), this._valDet.getDiscreteRangeValues(), this._newvalue);\r\n    }\r\n    return newTime;\r\n  }\r\n\r\n  /// <summary>Add found in newvalue numbers(2(or 1) letters) to buffer and return\r\n  /// last found number index\r\n  /// </summary>\r\n  /// <param name=\"currValue\">in newvalue</param>\r\n  /// <param name=\"buffer\">/// </param>\r\n  /// <param name=\"type\">which type of positional directive, for checking validity</param>\r\n  /// <returns> currValue in newvalue</returns>\r\n  private add2Time(currValue: number, buffer: StringBuilder, type: number): number {\r\n    let start: number = currValue;\r\n    let i: number;\r\n    let STR_00: String = \"00\";\r\n    let  currAdd: StringBuilder = new StringBuilder();\r\n\r\n    while (start < this._newvalue.length && !UtilStrByteMode.isDigit(this._newvalue[start]))\r\n    {\r\n      start++; // find first digit\r\n      // non-digits were found in input string\r\n      // we do not throw STR_ERR_TIME exception to prevent input digits lost\r\n      // on non-digits place STR_00 will be added\r\n      // Since Mask Editing . This error is irrelevant. Time now, always contains non digits like : and might contain ' ' for unfilled chars.\r\n      // This is a valid case and we do not want an error popping about it.\r\n      //  guiManager.writeToMessagePane(valDet.getControl().getForm().getTask(), ClientManager.Instance.getMessageString(STR_ERR_TIME), StatusBarMessageType.SB_RUNTIME_MSG);\r\n      //  setValidationFailed(true);\r\n    }\r\n\r\n    if (start === this._newvalue.length)\r\n    // not found more digits\r\n    {\r\n      buffer.Append(STR_00.toString());\r\n      return currValue;\r\n    }\r\n\r\n    for (i = start; i < start + 2 && i < this._newvalue.length; i++)\r\n    {\r\n      if (UtilStrByteMode.isDigit(this._newvalue[i]))\r\n        currAdd.Append(this._newvalue[i]);\r\n      else\r\n      {\r\n        currAdd.Insert(0, '0'); // only 1 digit found\r\n        break;\r\n      }\r\n    }\r\n\r\n    if (i === this._newvalue.length && i === start + 1)\r\n      currAdd.Insert(0, '0');\r\n    // only 1 digit found\r\n    else if (i === this._newvalue.length && i === start)\r\n      currAdd.Append(STR_00.toString());\r\n\r\n    let add: number = NNumber.Parse(currAdd.ToString());\r\n\r\n    /*if (add < 0)\r\n    currAdd=new StringBuffer(\"00\");\r\n    else if (add > 59 && type==PIC_MMT)\r\n    currAdd=new StringBuffer(\"59\");\r\n    else if (add > 59 && type==PIC_SS)\r\n    currAdd=new StringBuffer(\"59\");*/\r\n    if (add < 0 || (add > 59 && type === PICInterface.PIC_MMT) || (add > 59 && type === PICInterface.PIC_SS))\r\n      throw new WrongFormatException(MsgInterface.STR_ERR_TIME);\r\n    else if (type === PICInterface.PIC_HH)\r\n    {\r\n      let PM: boolean = this.getIsPM();\r\n      let newStr: String = null;\r\n      let dif: number;\r\n\r\n      if ((add >= 12 || add === 0) && PM)\r\n      {\r\n        let addTmp: number = add % 24;\r\n\r\n        this._isPm = (addTmp >= 12 && addTmp < 24);\r\n\r\n        if (addTmp > 12)\r\n          dif = addTmp - 12;\r\n        else if (addTmp === 0)\r\n          dif = 12;\r\n        else\r\n          dif = addTmp;\r\n\r\n        newStr = ((dif > 9 ? \"\" : \"0\") + dif);\r\n      }\r\n      else if (add > 99 && !PM)\r\n        newStr = \"99\";\r\n\r\n      if (newStr != null)\r\n      {\r\n        currAdd.Remove(0, currAdd.Length);\r\n        currAdd.Append(newStr.toString());\r\n      }\r\n    }\r\n\r\n    buffer.Append(currAdd.ToString());\r\n    return i;\r\n  }\r\n\r\n  /// <summary>Append PM or AM to time</summary>\r\n  private addPM2Time(currValue: number, buffer: StringBuilder): number {\r\n    let i: number;\r\n\r\n    if ((i = this._newvalue.toUpperCase().indexOf(\"AM\", currValue)) !== -1)\r\n    {\r\n      buffer.Append(\"am\");\r\n      return i + 2;\r\n    }\r\n    else\r\n    {\r\n      if ((i = this._newvalue.toUpperCase().indexOf(\"PM\", currValue)) !== -1)\r\n      {\r\n        buffer.Append(\"pm\");\r\n        return i + 2;\r\n      }\r\n      else if (this._isPm)\r\n      {\r\n        buffer.Append(\"pm\");\r\n        return currValue;\r\n      }\r\n      else\r\n        buffer.Append(\"am\");\r\n    }\r\n    return currValue;\r\n  }\r\n\r\n  /// <summary>Check if where is 'PM' positional directive in the Time Picture</summary>\r\n  /// <returns> true - there is PM, else false</returns>\r\n  private getIsPM(): boolean {\r\n\r\n    for (let curr: number = 0; curr < this._picture.length; curr++)\r\n    {\r\n      if (this._picture.charCodeAt(curr) === PICInterface.PIC_PM)\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  private fillTimeByRange(ContinuousRange: List<string>, DiscreteRange: List<string>, buffer: Date): Date {\r\n    let  pic: PIC = this._valDet.getPIC();\r\n    let  currTime: number = DisplayConvertor.Instance.fromNativeTimeToMgTimeNumber(buffer);\r\n    let downTime: number, topTime: number;\r\n    let i: number;\r\n\r\n    this.setValidationFailed(false);\r\n    if (ContinuousRange != null)\r\n    {\r\n      for (i = 0; i < ContinuousRange.length - 1; i++)\r\n      {\r\n        downTime = DisplayConvertor.Instance.a_2_time(ContinuousRange.get_Item(i), pic, false);\r\n        topTime = DisplayConvertor.Instance.a_2_time(ContinuousRange.get_Item(++i), pic, false);\r\n        if (currTime >= downTime && currTime <= topTime)\r\n          return new Date(buffer);\r\n      }\r\n    }\r\n\r\n    if (DiscreteRange != null)\r\n    {\r\n      for (i = 0; i < DiscreteRange.length; i++)\r\n      {\r\n        if (currTime === DisplayConvertor.Instance.a_2_time(DiscreteRange.get_Item(i), pic, false))\r\n          return new Date(buffer);\r\n      }\r\n    }\r\n    // the time is not in the range\r\n    throw new WrongFormatException();\r\n  }\r\n\r\n  /// <summary>*************************************************************\r\n  /// SERVICE functions\r\n  /// ***************************************************************\r\n  /// </summary>\r\n\r\n  /// <summary> print ERROR prompt message about range to status bar</summary>\r\n  /// <param name=\"msgId\">of error Message</param>\r\n  /// <param name=\"setValidationFaild\">validation failed</param>\r\n  private printMessage(msgId: string, setValidationFaild: boolean): void {\r\n    let message: StringBuilder = new StringBuilder(\"\");\r\n    let ctrlType: MgControlType;\r\n\r\n    if (msgId === MsgInterface.EDT_ERR_STR_1)\r\n    {\r\n      let pic: PIC = this._valDet.getPIC();\r\n      let token: string = \"%d\";\r\n      let messageString: string = Events.GetMessageString(msgId);\r\n      messageString = StrUtil.replaceStringTokens(messageString, token, 1, pic.getWholes().toString());\r\n      messageString = StrUtil.replaceStringTokens(messageString, token, 1, pic.getDec().toString());\r\n      message.Append(messageString);\r\n    }\r\n    else\r\n    {\r\n      message.Append(Events.GetMessageString(msgId));\r\n      if (msgId === MsgInterface.STR_RNG_TXT && this._valDet.getRange() != null)\r\n        message.Append(StrUtil.makePrintableTokens(this._valDet.getRange(), HTML_2_STR));\r\n    }\r\n\r\n    if (this._valDet.getControl() != null)\r\n    {\r\n      ctrlType = this._valDet.getControl().Type;\r\n      if (ctrlType !== MgControlType.CTRL_TYPE_BUTTON && ctrlType !== MgControlType.CTRL_TYPE_RADIO && !this._valDet.getControl().isSelectionCtrl())\r\n      {\r\n        let msgString: string = message.ToString();\r\n        this._valDet.getControl().getForm().getTask().WriteToMessagePane(StrUtil.makePrintable2(msgString));\r\n        this._valDet.getControl().getForm().ErrorOccured = !NString.IsNullOrEmpty(msgString);\r\n        this._valDet.ErrorMessage = message.ToString();\r\n      }\r\n    }\r\n    if (setValidationFaild)\r\n    // from this point the focus send back to control and setValidationFailed(true) can not set it to true\r\n      this.setValidationFailed(true);\r\n  }\r\n\r\n  /// <summary>Change inside 'newvalue' substring on position 'index' to string 'to'</summary>\r\n  /// <param name=\"newvalue\">to change inside</param>\r\n  /// <param name=\"to\">string to change by him</param>\r\n  /// <param name=\"index\">the substring to change on the position</param>\r\n  private changeStringInside(to: string, index: number): void {\r\n    this._newvalue = this._newvalue.substr(0, index) + to +  this._newvalue.substr(index + to.length);\r\n  }\r\n\r\n  private init(validationDetails: ValidationDetails): void {\r\n    this._valDet = validationDetails;\r\n    this._valDet.setNull(false);\r\n    this._isPm = false;\r\n    let pIC: PIC = this._valDet.getPIC();\r\n    this._oldvalue = this._valDet.getOldValue();\r\n    this._newvalue = this._valDet.getDispValue();\r\n\r\n    if (this._newvalue === null) {\r\n      if (pIC == null  || pIC.getAttr() != StorageAttribute.DATE)\r\n        this._newvalue = \"\";\r\n    }\r\n\r\n    if (this._oldvalue === null) {\r\n      this._oldvalue = \"\";\r\n    }\r\n\r\n    if (!(pIC === null || pIC.getAttr() === StorageAttribute.BLOB || pIC.getAttr() === StorageAttribute.BLOB_VECTOR)) {\r\n      this._picture = pIC.getMask();\r\n      this.hebrew = pIC.isHebrew();\r\n      this._picture = this._picture.substr(0, pIC.getMaskSize());\r\n    }\r\n  }\r\n\r\n  /// <summary>Return index of Max member in array</summary>\r\n  private findMax(array: number[]): number {\r\n    let index: number = 0;\r\n    let max: number = array[index];\r\n    for (let i: number = 1; i < array.length; i++)\r\n    {\r\n      if (array[i] > max)\r\n      {\r\n        max = array[i];\r\n        index = i;\r\n      }\r\n    }\r\n    return index;\r\n  }\r\n  /// <summary>is checked char Data Positional Directive</summary>\r\n  private isDataPositionalDirective(toCheck: string): boolean {\r\n    let ascii: number = toCheck.charCodeAt(0);\r\n    return (ascii === PICInterface.PIC_YY || ascii === PICInterface.PIC_YYYY || ascii === PICInterface.PIC_MMD || ascii === PICInterface.PIC_MMM\r\n      || ascii === PICInterface.PIC_DD || ascii === PICInterface.PIC_DDD || ascii === PICInterface.PIC_DDDD || ascii === PICInterface.PIC_W\r\n      || ascii === PICInterface.PIC_WWW || ascii === PICInterface.PIC_HYYYYY || ascii === PICInterface.PIC_HL || ascii === PICInterface.PIC_HDD || ascii === PICInterface.PIC_YJ\r\n      || ascii === PICInterface.PIC_JY1 || ascii === PICInterface.PIC_JY2 || ascii === PICInterface.PIC_JY4 || ascii === PICInterface.PIC_BB); // JPN: Japanese date picture support\r\n\r\n  }\r\n\r\n  /// <summary>check if Numeric Data Positional Directive exists</summary>\r\n  private isDatePositionalNumericDirective(toCheck: string): boolean {\r\n    let ascii: number = toCheck.charCodeAt(0);\r\n    return (ascii === PICInterface.PIC_YY || ascii === PICInterface.PIC_YYYY || ascii === PICInterface.PIC_MMD || ascii === PICInterface.PIC_DD\r\n      || ascii === PICInterface.PIC_DDD || ascii === PICInterface.PIC_DDDD || ascii === PICInterface.PIC_W || ascii === PICInterface.PIC_HYYYYY\r\n      || ascii === PICInterface.PIC_HL || ascii === PICInterface.PIC_HDD || ascii === PICInterface.PIC_YJ || ascii === PICInterface.PIC_JY1\r\n      || ascii === PICInterface.PIC_JY2 || ascii === PICInterface.PIC_JY4 || ascii === PICInterface.PIC_BB); // JPN: Japanese date picture support\r\n\r\n  }\r\n\r\n  /// <summary>is checked char Numeric Positional Directive</summary>\r\n  private isNumericPositionalDirective(toCheck: string): boolean {\r\n    let ascii: number = toCheck.charCodeAt(0);\r\n    return (ascii === PICInterface.PIC_N);\r\n\r\n  }\r\n\r\n  /// <summary>is checked char Logic Positional Directive</summary>\r\n  private isLogicPositionalDirective(toCheck: string): boolean {\r\n    let ascii: number = toCheck.charCodeAt(0);\r\n    return (ascii === PICInterface.PIC_X);\r\n\r\n  }\r\n\r\n  /// <summary>Find if the letter at index is Positional Date Directive</summary>\r\n  /// <param name=\"char\">to check in picture</param>\r\n  /// <returns> true if Positional Date Directive; false otherwise</returns>\r\n  private isTimePositionalDirective(toCheck: string): boolean {\r\n    let ascii: number = toCheck.charCodeAt(0);\r\n    return (ascii === PICInterface.PIC_HH || ascii === PICInterface.PIC_MMT || ascii === PICInterface.PIC_SS || ascii === PICInterface.PIC_PM || ascii === PICInterface.PIC_MS);\r\n\r\n  }\r\n\r\n  /// <summary>is checked string Positional Directive of any type</summary>\r\n  /// <param name=\"full/part\">of picture\r\n  /// </param>\r\n  /// <returns> index of directive position or -1 if not found</returns>\r\n  private indexOfPositionalNonDirective(str: string): number {\r\n    let tmp: string;\r\n\r\n    for (let i: number = 0; i < str.length; i++)\r\n    {\r\n      tmp = str[i];\r\n      if (DisplayConvertor.isAlphaPositionalDirective(tmp) || this.isDataPositionalDirective(tmp) || this.isNumericPositionalDirective(tmp)\r\n        || this.isLogicPositionalDirective(tmp) || this.isTimePositionalDirective(tmp))\r\n        continue;\r\n      return i;\r\n    }\r\n    return -1;\r\n  }\r\n\r\n  /// <summary> set the \"validation failed\" flag</summary>\r\n  /// <param name=\"val\">value to use</param>\r\n  private setValidationFailed(val: boolean): void {\r\n    if (this._valDet.ValidationFailed)\r\n      return;\r\n    else\r\n      this._valDet.setValidationFailed(val);\r\n  }\r\n\r\n  /// <summary> Count digits in string before delimeter</summary>\r\n  /// <param name=\"inputString\">- string to look into for delimeter</param>\r\n  /// <param name=\"searchStart\">- initial index position for search in inputString</param>\r\n  /// <param name=\"delimeter\">we are looking for</param>\r\n  private digitsBeforeDelimeter(inputString: string, searchStart: number, delimeter: string): number {\r\n    let counter: number = 0;\r\n    let searchEndPos: number = inputString.indexOf(delimeter, searchStart);\r\n\r\n    if (searchEndPos < 0)\r\n      searchEndPos = inputString.length;\r\n\r\n    for (let i: number = searchStart; i < searchEndPos; i++)\r\n    if (NChar.IsDigit(inputString[i]))\r\n      counter++;\r\n\r\n    return counter;\r\n  }\r\n\r\n  /// <summary> by Ctrl+U (Set to Null), null display value is set to ctrl. In this case we need following checking , in order to set field to null.</summary>\r\n  /// <param name=\"val\">- entered value to value to check</param>\r\n  private isNullDisplayVal(): boolean {\r\n    let isNullDisplayVal: boolean = false;\r\n    let field: GuiFieldBase = this._valDet.getControl().getField();\r\n\r\n    if (field.NullAllowed && field.hasNullDisplayValue())\r\n    {\r\n      let dispDefValue: any = field.getNullDisplay();\r\n      if (dispDefValue !== null)\r\n        isNullDisplayVal = (dispDefValue.toString() === this._newvalue);\r\n      else\r\n        isNullDisplayVal = (this._newvalue === null);\r\n    }\r\n\r\n    return isNullDisplayVal;\r\n  }\r\n}\r\n"]}