/// <summary> /// JGENGO: Return Japanese gengo (the name of an era) /// </summary> protected internal void eval_op_jgengo(ExpressionEvaluator.ExpVal resVal, NUM_TYPE val1, NUM_TYPE val2, DisplayConvertor displayConvertor) { String strFormat; int intType; resVal.Attr = StorageAttribute.ALPHA; if (val1 == null || val2 == null) { _expressionEvaluator.SetNULL(resVal, StorageAttribute.ALPHA); return; } intType = val2.NUM_2_LONG(); if (intType >= 4) { strFormat = "JJJJ"; } else if (intType >= 2) { strFormat = "JJ"; } else if (intType >= 1) { strFormat = "J"; } else { resVal.StrVal = ""; return; } _expressionEvaluator.eval_op_date_str(resVal, val1, strFormat, displayConvertor); }
/// <summary> /// Converts Magic 'Date' Type to 'dotNetType' /// </summary> /// <param name="magicVal"></param> /// <param name="dotNetType"></param> /// <returns></returns> private static object convertDateToDotNet(string magicVal, Type dotNetType) { if (dotNetType == typeof(DateTime)) { NUM_TYPE numType = new NUM_TYPE(magicVal); DisplayConvertor displayConvertor = DisplayConvertor.Instance; int date = numType.NUM_2_LONG(); if (date == 0) { magicVal = FieldDef.getMagicDefaultValue(StorageAttribute.DATE); numType = new NUM_TYPE(magicVal); date = numType.NUM_2_LONG(); } // Break date into its components - year month date DisplayConvertor.DateBreakParams breakParams = displayConvertor.getNewDateBreakParams(); displayConvertor.date_break_datemode(breakParams, date, true, -1); int year = breakParams.year; int month = breakParams.month; int day = breakParams.day; return(new DateTime(year, month, day)); } else { return(null); } }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { NUM_TYPE type = (NUM_TYPE)value; string s_type; switch (type) { case NUM_TYPE.DEC: s_type = "DEC"; break; case NUM_TYPE.HEX: s_type = "HEX"; break; case NUM_TYPE.BIN: s_type = "BIN"; break; default: s_type = ""; break; } return(s_type); }
/// <summary> /// Converts 'dotNetObj' to 'Time' Magic type /// </summary> /// <param name="dotNetObj"></param> /// <returns></returns> private static string convertDotNetToTime(object dotNetObj) { String retObject = ""; Type dotNetType = dotNetObj.GetType(); if (dotNetType == typeof(DateTime)) { DateTime date = (DateTime)dotNetObj; int magicTime = DisplayConvertor.Instance.time_2_int(date.Hour, date.Minute, date.Second); NUM_TYPE numtypeMagicTime = new NUM_TYPE(); numtypeMagicTime.NUM_4_LONG(magicTime); retObject = numtypeMagicTime.toXMLrecord(); } else if (dotNetType == typeof(TimeSpan)) { TimeSpan time = (TimeSpan)dotNetObj; int magicTime = DisplayConvertor.Instance.time_2_int(time.Hours, time.Minutes, time.Seconds); NUM_TYPE numtypeMagicTime = new NUM_TYPE(); numtypeMagicTime.NUM_4_LONG(magicTime); retObject = numtypeMagicTime.toXMLrecord(); } return(retObject); }
/// <summary> /// Converts Magic 'Numeric' Type to 'dotNetType' /// </summary> /// <param name="magicVal"></param> /// <param name="dotNetType"></param> /// <returns></returns> private static Object convertNumericToDotNet(String magicVal, Type dotNetType) { Object retObject = null; NUM_TYPE numType = new NUM_TYPE(magicVal); double doubleVal = 0.0; if (dotNetType == typeof(SByte) || dotNetType == typeof(Byte) || dotNetType == typeof(Int16) || dotNetType == typeof(UInt16) || dotNetType == typeof(Int32) || dotNetType == typeof(UInt32) || dotNetType == typeof(Int64) || dotNetType == typeof(UInt64) || dotNetType == typeof(float) || dotNetType == typeof(Decimal) || dotNetType == typeof(Single) || dotNetType == typeof(Double)) { doubleVal = numType.to_double(); retObject = ReflectionServices.DynCast(doubleVal, dotNetType); } else { doubleVal = numType.to_double(); if (dotNetType == typeof(Char)) { retObject = ReflectionServices.DynCast((Int64)doubleVal, dotNetType); } else if (dotNetType == typeof(IntPtr)) { retObject = new IntPtr((long)doubleVal); } else if (dotNetType == typeof(UIntPtr)) { retObject = new UIntPtr((ulong)doubleVal); } } return(retObject); }
internal override object ConvertRuntimeFieldToGateway(DBField dbField, string gatewayValue) { NUM_TYPE A = new NUM_TYPE(gatewayValue); //return ((NUM_TYPE)gatewayValue).to_double().ToString(); return(ConvertMgValueToGateway(dbField, A)); }
/// <summary> /// /// </summary> /// <param name="fieldView"></param> /// <param name="userRange"></param> /// <returns></returns> private UnitComputeResult CheckUserRange(IFieldView fieldView, UserRange userRange) { UnitComputeResult result = new UnitComputeResult(); string fieldValue = fieldView.ValueFromCurrentRecord.Trim(); switch (fieldView.StorageAttribute) { case StorageAttribute.NUMERIC: case StorageAttribute.DATE: case StorageAttribute.TIME: { int fieldValueInt = new NUM_TYPE(fieldValue).NUM_2_LONG(); // check the min value if (!userRange.nullMin && !userRange.discardMin) { int min = new NUM_TYPE(userRange.min).NUM_2_LONG(); if (fieldValueInt < min) { result.ErrorCode = UnitComputeErrorCode.RangeFailed; } } // check the max value if (result.Success && !userRange.nullMax && !userRange.discardMax) { int max = new NUM_TYPE(userRange.max).NUM_2_LONG(); if (fieldValueInt > max) { result.ErrorCode = UnitComputeErrorCode.RangeFailed; } } } break; default: { // check the min value if (!userRange.nullMin && !userRange.discardMin) { if (String.Compare(fieldValue, (string)userRange.min, StringComparison.Ordinal) < 0) { result.ErrorCode = UnitComputeErrorCode.RangeFailed; } } // check the max value if (result.Success && !userRange.nullMax && !userRange.discardMax) { if (String.Compare(fieldValue, (string)userRange.max, StringComparison.Ordinal) > 0) { result.ErrorCode = UnitComputeErrorCode.RangeFailed; } } } break; } return(result); }
/// <summary> convert numbers to our secret format /// </summary> /// <param name="fileName"></param> private static String Encode(String numStr, StorageAttribute attr, String picStr) { PIC pic = new PIC(picStr, attr, 0); NUM_TYPE num_type = new NUM_TYPE(numStr, pic, 0); String encoded_num = num_type.toXMLrecord(); encoded_num = Base64.encode(RecordUtils.byteStreamToString(encoded_num), ClientManager.Instance.getEnvironment().GetEncoding()); return(XmlParser.escape(encoded_num)); }
/// <summary> /// Ref to coversion table in ConvertMagicToDotNet, gets the default DotNetType for 'magicType' /// </summary> /// <param name="magicType"></param> /// <returns></returns> public static Type getDefaultDotNetTypeForMagicType(String magicVal, StorageAttribute magicType) { Type dotNetType = null; switch (magicType) { case StorageAttribute.NUMERIC: NUM_TYPE numType = new NUM_TYPE(magicVal); if (numType.NUM_IS_LONG()) { dotNetType = typeof(long); } else { dotNetType = typeof(Double); } break; case StorageAttribute.ALPHA: case StorageAttribute.UNICODE: dotNetType = typeof(String); break; case StorageAttribute.DATE: dotNetType = typeof(DateTime); break; case StorageAttribute.TIME: dotNetType = typeof(TimeSpan); break; case StorageAttribute.BOOLEAN: dotNetType = typeof(Boolean); break; case StorageAttribute.BLOB: dotNetType = typeof(String); break; case StorageAttribute.BLOB_VECTOR: dotNetType = typeof(Array); break; case StorageAttribute.DOTNET: dotNetType = typeof(Object); break; default: break; } return(dotNetType); }
/// <summary> convert numbers from our secret format /// </summary> /// <param name="fileName"></param> private static String Decode(String numStr, StorageAttribute attr, String picStr) { String decoded_num = XmlParser.unescape(numStr); decoded_num = XmlParser.unescape(decoded_num); decoded_num = Base64.decodeToHex(decoded_num); NUM_TYPE num_type = new NUM_TYPE(decoded_num); PIC pic = new PIC(picStr, attr, 0); return(num_type.toDisplayValue(pic)); }
private void setNumericVals() { if (_isNumericType && _linkVals != null) { _numVals = new NUM_TYPE[_linkVals.Length]; for (int j = 0; j < _linkVals.Length; j++) { _numVals[j] = new NUM_TYPE(_linkVals[j]); } } else { _numVals = null; } }
internal override object ConvertGatewayToRuntimeField(DBField dbField, object gatewayValue) { NUM_TYPE value = new NUM_TYPE(); if (dbField.Length <= 2) { value.NUM_4_LONG((short)gatewayValue); } else { value.NUM_4_LONG((int)gatewayValue); } return(value.toXMLrecord()); }
/// <summary> /// Converts 'dotNetObj' to 'Date' Magic type /// </summary> /// <param name="dotNetObj"></param> /// <returns></returns> private static string convertDotNetToDate(object dotNetObj) { String retObject = ""; Type dotNetType = dotNetObj.GetType(); if (dotNetType == typeof(DateTime)) { DateTime date = (DateTime)dotNetObj; int magicDate = DisplayConvertor.Instance.date_4_calender(date.Year, date.Month, date.Day, 0, false); NUM_TYPE numtypeMagicDate = new NUM_TYPE(); numtypeMagicDate.NUM_4_LONG(magicDate); retObject = numtypeMagicDate.toXMLrecord(); } return(retObject); }
/// <summary>Adds the pane to the status bar/// </summary> /// <param name="statusBarIdx">Status bar index</param> /// <param name="paneType">Pane type: label or image</param> /// <param name="paneIdx">Pane index</param> /// <param name="paneWidth">Pane width</param> /// <param name="showPaneBorder">Show border or not</param> public void AddPane(MgControlType paneType, int paneIdx, int paneWidth, bool showPaneBorder) { var num = new NUM_TYPE(); //Get status bar index. int statusBarIdx = getForm().getControlIdx(this); // Create pane object MgControlBase paneObj = getForm().ConstructMgControl(paneType, getForm().getTask(), statusBarIdx); if (paneObj != null) { // Set width of pane object. num.NUM_4_LONG(paneWidth); paneObj.setProp(PropInterface.PROP_TYPE_WIDTH, num.toXMLrecord()); // Set Idx of pane object. num.NUM_4_LONG(paneIdx); paneObj.setProp(PropInterface.PROP_TYPE_LAYER, num.toXMLrecord()); // Set border of pane object. if (showPaneBorder) { paneObj.setProp(PropInterface.PROP_TYPE_BORDER, "1"); } //Properties specific to image pane only. if (paneObj.Type == MgControlType.CTRL_TYPE_SB_IMAGE) { paneObj.DataType = StorageAttribute.ALPHA; paneObj.setPIC("1000"); num.NUM_4_LONG((int)CtrlImageStyle.Copied); paneObj.setProp(PropInterface.PROP_TYPE_IMAGE_STYLE, num.toXMLrecord()); } //Add to control table collection. getForm().CtrlTab.addControl(paneObj); //Add to collection. Debug.Assert(!_paneObjectsCollection.ContainsKey(paneIdx)); _paneObjectsCollection[paneIdx] = paneObj; } }
/// <summary> /// Converts 'dotNetObj' to 'Numeric' Magic type /// </summary> /// <param name="dotNetObj"></param> /// <returns></returns> private static string convertDotNetToNumeric(object dotNetObj) { Double doubleVal = 0.0; Type dotNetType = dotNetObj.GetType(); NUM_TYPE numType; if (dotNetType.IsEnum) { dotNetType = Enum.GetUnderlyingType(dotNetType); } if (dotNetType == typeof(SByte) || dotNetType == typeof(Byte) || dotNetType == typeof(Int16) || dotNetType == typeof(UInt16) || dotNetType == typeof(Int32) || dotNetType == typeof(Char)) { int intVal = (int)ReflectionServices.DynCast(dotNetObj, typeof(int)); numType = new NUM_TYPE(); numType.NUM_4_LONG(intVal); } else if (dotNetType == typeof(UInt32) || dotNetType == typeof(Int64) || dotNetType == typeof(UInt64) || dotNetType == typeof(float) || dotNetType == typeof(Decimal) || dotNetType == typeof(Single) || dotNetType == typeof(Double)) { doubleVal = (Double)ReflectionServices.DynCast(dotNetObj, typeof(Double)); numType = NUM_TYPE.from_double(doubleVal); } else { if (dotNetType == typeof(IntPtr)) { doubleVal = (Double)((IntPtr)dotNetObj).ToInt64(); } else if (dotNetType == typeof(UIntPtr)) { doubleVal = (Double)((UIntPtr)dotNetObj).ToUInt64(); } numType = NUM_TYPE.from_double(doubleVal); } return(numType.toXMLrecord()); }
/// <summary> /// Build the expression as a byte array /// </summary> private void buildByteArray(String expStr) { String twoHexDigits; if (expStr == null || expStr.Length == 0 || expStr.Length % 2 != 0) { Logger.Instance.WriteExceptionToLog("in Expression.buildByteArray() expStr cannot be changed " + expStr); return; } _expBytes = new sbyte[expStr.Length / 2]; for (int i = 0; i < expStr.Length; i += 2) { twoHexDigits = expStr.Substring(i, 2); _expBytes[i / 2] = NUM_TYPE.toSByte(Convert.ToInt32(twoHexDigits, 16)); } }
/// <summary> /// /// </summary> /// <param name="record"></param> /// <param name="checkRange"></param> /// <returns></returns> internal override UnitComputeResult Compute(IRecord record, bool checkRange, bool recompute, bool computeInitExpressions) { UnitComputeResult result = new UnitComputeResult(); string fieldValue = fieldView.ValueFromCurrentRecord; switch (fieldView.StorageAttribute) { case StorageAttribute.NUMERIC: { NUM_TYPE fetchedValue = new NUM_TYPE(fieldValue); NUM_TYPE minimumValue = new NUM_TYPE(DisplayConvertor.Instance.toNum((string)minValue, new PIC(fieldView.Picture, StorageAttribute.NUMERIC, 0), 0)); if (NUM_TYPE.num_cmp(fetchedValue, minimumValue) < 0) { result.ErrorCode = UnitComputeErrorCode.LocateFailed; } } break; case StorageAttribute.UNICODE: case StorageAttribute.ALPHA: { //QCR # 444514 : Check whether given Incremental Locate String is in between min and max of fetched value. // Locate gets successful when fetched record is greater than or equal to search Incremental Locate String value. string minimumValue = minValue.ToString().PadRight(fieldView.Length, char.MinValue); string maximumValue = minValue.ToString().PadRight(fieldView.Length, char.MaxValue); if (String.Compare(fieldValue, (string)minimumValue, StringComparison.Ordinal) < 0) { result.ErrorCode = UnitComputeErrorCode.LocateFailed; } else if (String.Compare(fieldValue, (string)maximumValue, StringComparison.Ordinal) > 0) { result.ErrorCode = UnitComputeErrorCode.LocateFailed; } } break; } return(result); }
/// <summary> /// convert the string typed by the user to the type the gateway converter expects /// </summary> /// <param name="type"></param> /// <param name="value"></param> /// <param name="length"></param> /// <returns></returns> private object StringToMgVal(StorageAttribute type, string value, int length, string picture) { switch (type) { case StorageAttribute.ALPHA: case StorageAttribute.UNICODE: { String newVal = value; newVal = newVal.PadRight(length, '\0'); return(newVal); } case StorageAttribute.NUMERIC: NUM_TYPE numType = new NUM_TYPE(value, new PIC(picture, StorageAttribute.NUMERIC, 0), 0); return(numType); default: Debug.Assert(false, "Unhandled case in incremental locate"); return(value); } }
internal override object ConvertGatewayToRuntimeField(DBField dbField, object gatewayValue) { NUM_TYPE runtimeValue = new NUM_TYPE(); String numberString = gatewayValue.ToString(); if (dbField.Dec > 0) { string systemNumberDecimalSeperator = CultureInfo.CurrentUICulture.NumberFormat.NumberDecimalSeparator; char decimalSeparator = ClientManager.Instance.getEnvironment().GetDecimal(); // temporarily exclude this code from Windows mobile. When handling offline and client side storage on Windows mobile // please handle this too #if !PocketPC if (!decimalSeparator.Equals(systemNumberDecimalSeperator) && numberString.Contains(systemNumberDecimalSeperator)) { numberString = numberString.Replace(systemNumberDecimalSeperator, decimalSeparator.ToString()); } #endif } runtimeValue.num_4_a_std((string)numberString); return(runtimeValue.toXMLrecord()); }
public void Convert(DBField sourceField, DBField destinationField, FieldValue sourceValue, FieldValue destinationValue) { switch ((StorageAttribute)destinationField.Attr) { case StorageAttribute.ALPHA: case StorageAttribute.UNICODE: var pic = new PIC(sourceField.Picture, StorageAttribute.NUMERIC, 0); destinationValue.Value = DisplayConvertor.Instance.mg2disp(sourceValue.Value.ToString(), null, pic, false, 0, true, false); break; case StorageAttribute.BOOLEAN: NUM_TYPE num = new NUM_TYPE(sourceValue.Value.ToString()); destinationValue.Value = num.NUM_2_LONG() > 0 ? "1" : "0"; break; case StorageAttribute.NUMERIC: case StorageAttribute.DATE: case StorageAttribute.TIME: destinationValue.Value = sourceValue.Value; break; } }
/// <summary> /// creates only a real refresh event command /// </summary> /// <returns>newly created command.</returns> internal static RefreshEventCommand CreateRealRefreshCommand(String taskId, int magicEvent, int currentRow, ArgumentsList argList, int currentRecId) { RefreshEventCommand cmd = new RefreshEventCommand(magicEvent) { TaskTag = taskId, RefreshMode = ViewRefreshMode.CurrentLocation, KeepUserSort = false, ClientRecId = currentRecId, CurrentRecordRow = currentRow }; if (argList != null && argList.getSize() != 0) { try { var refreshMode = new NUM_TYPE(argList.getArgValue(0, StorageAttribute.NUMERIC, 0)); cmd.RefreshMode = (ViewRefreshMode)refreshMode.NUM_2_LONG() + 1; } catch (Exception) { cmd.RefreshMode = ViewRefreshMode.CurrentLocation; } if (argList.getSize() > 1) { try { cmd.KeepUserSort = (argList.getArgValue(1, StorageAttribute.BOOLEAN, 0) == "1"); } catch (Exception) { cmd.KeepUserSort = false; } } } return(cmd); }
/// <summary> /// Converts Magic 'Time' Type to 'dotNetType' /// </summary> /// <param name="magicVal"></param> /// <param name="dotNetType"></param> /// <returns></returns> private static object convertTimeToDotNet(string magicVal, Type dotNetType) { Object retObject = null; if (dotNetType == typeof(DateTime) || dotNetType == typeof(TimeSpan)) { NUM_TYPE numType = new NUM_TYPE(magicVal); DisplayConvertor displayConvertor = DisplayConvertor.Instance; int time = numType.NUM_2_ULONG(); // Break time into its components - hour min sec DisplayConvertor.TimeBreakParams breakParams = displayConvertor.getNewTimeBreakParams(); DisplayConvertor.time_break(breakParams, time); int hour = breakParams.hour; int minute = breakParams.minute; int second = breakParams.second; if (dotNetType == typeof(DateTime)) { DateTime dateTimeObj = new DateTime(); dateTimeObj = dateTimeObj.AddHours(hour); dateTimeObj = dateTimeObj.AddMinutes(minute); dateTimeObj = dateTimeObj.AddSeconds(second); retObject = dateTimeObj; } else if (dotNetType == typeof(TimeSpan)) { retObject = new TimeSpan(hour, minute, second); } } return(retObject); }
/// creates an Index Change event command /// </summary> /// <returns>newly created command.</returns> internal static IndexChangeEventCommand CreateIndexChangeCommand(string taskTag, int recId, ArgumentsList argList) { IndexChangeEventCommand cmd = new IndexChangeEventCommand { TaskTag = taskTag, ClientRecId = recId }; // 1 parameter : The new Key Index if (argList != null && argList.getSize() != 0) { try { var keyIndex = new NUM_TYPE(argList.getArgValue(0, StorageAttribute.NUMERIC, 0)); cmd.KeyIndex = keyIndex.NUM_2_LONG(); } catch (Exception) { cmd.KeyIndex = 0; } } return(cmd); }
/// <summary> /// JCDOW: Japanese version of CDOW /// </summary> protected internal void eval_op_jcdow(ExpressionEvaluator.ExpVal resVal, NUM_TYPE val1, DisplayConvertor displayConvertor) { _expressionEvaluator.eval_op_date_str(resVal, val1, "SSSSSST", displayConvertor); }
/// <summary> /// /// </summary> /// <param name="itemVal"></param> /// <param name="itemAttr"></param> /// <returns></returns> public static byte[] serializeItemVal(String itemVal, StorageAttribute itemAttr) { Debug.Assert(itemVal != null); string valueSize; string tmpBufLen = string.Empty; Byte [] tmpBuf = null; List <byte> contentWithLength = new List <byte>(); int pos = 0; int fldValLen = 0; String tempItemVal = string.Empty; int noOfPackets = 0; Byte [] tmpNoOfPackets = null; String tmpStrNoOfPackets = string.Empty; switch (itemAttr) { case StorageAttribute.NUMERIC: case StorageAttribute.DATE: case StorageAttribute.TIME: NUM_TYPE numType = new NUM_TYPE(itemVal); tmpBuf = Misc.ToByteArray(numType.Data); break; case StorageAttribute.BOOLEAN: tmpBuf = Manager.Environment.GetEncoding().GetBytes(itemVal); break; case StorageAttribute.ALPHA: itemVal = StrUtil.rtrim(itemVal); valueSize = (Convert.ToString(UtilStrByteMode.lenB(itemVal), 16)).ToUpper(); // add leading zeros (if needed) for (int j = 0; j < 4 - valueSize.Length; j++) { tmpBufLen += "0"; } tmpBufLen += valueSize; contentWithLength.AddRange(Manager.Environment.GetEncoding().GetBytes(tmpBufLen)); contentWithLength.AddRange(Manager.Environment.GetEncoding().GetBytes(itemVal)); tmpBuf = new byte[contentWithLength.Count]; contentWithLength.CopyTo(tmpBuf); break; case StorageAttribute.UNICODE: itemVal = StrUtil.rtrim(itemVal); valueSize = (Convert.ToString(itemVal.Length, 16)).ToUpper(); // add leading zeros (if needed) for (int j = 0; j < 4 - valueSize.Length; j++) { tmpBufLen += "0"; } tmpBufLen += valueSize; contentWithLength.AddRange(Manager.Environment.GetEncoding().GetBytes(tmpBufLen)); contentWithLength.AddRange(Encoding.Unicode.GetBytes(itemVal)); tmpBuf = new byte[contentWithLength.Count]; contentWithLength.CopyTo(tmpBuf); break; case StorageAttribute.BLOB: pos = 0; // blob will be serialized in packet of size 0xFFFF. // So format of serialized buffer for blob is // no. of packets (n) + length1 + data1 + length2 + data2 + ......length n + datan fldValLen = ISO_8859_1_Encoding.getInstance().GetByteCount(itemVal); noOfPackets = (int)fldValLen / 0xFFFF; tmpBufLen = "FFFF"; tmpNoOfPackets = Manager.Environment.GetEncoding().GetBytes(tmpBufLen); for (int i = 0; i < noOfPackets; i++) { tempItemVal = itemVal.Substring(pos, 0xFFFF); pos += 0xFFFF; contentWithLength.AddRange(tmpNoOfPackets); contentWithLength.AddRange(ISO_8859_1_Encoding.getInstance().GetBytes(tempItemVal)); } int lastPacketSize = fldValLen % 0xFFFF; if (lastPacketSize > 0) { tempItemVal = itemVal.Substring(pos, (fldValLen) - (pos)); byte[] tempItemValBytes = ISO_8859_1_Encoding.getInstance().GetBytes(tempItemVal); tmpBufLen = tempItemValBytes.Length.ToString("X4"); contentWithLength.AddRange(Manager.Environment.GetEncoding().GetBytes(tmpBufLen)); contentWithLength.AddRange(ISO_8859_1_Encoding.getInstance().GetBytes(tempItemVal)); noOfPackets++; } tmpStrNoOfPackets = noOfPackets.ToString("D4"); tmpNoOfPackets = Manager.Environment.GetEncoding().GetBytes(tmpStrNoOfPackets); tmpBuf = new byte[contentWithLength.Count + tmpNoOfPackets.Length]; tmpNoOfPackets.CopyTo(tmpBuf, 0); contentWithLength.CopyTo(tmpBuf, tmpNoOfPackets.Length); break; } //end of the type case block return(tmpBuf); }
/// <summary> /// /// </summary> /// <param name="dbField"></param> /// <param name="gatewayValue"></param> /// <returns></returns> internal override object ConvertRuntimeFieldToGateway(DBField dbField, string runtimeValue) { NUM_TYPE mgNum = new NUM_TYPE(runtimeValue); return(ConvertMgValueToGateway(dbField, mgNum)); }
/// <returns> translation of this argument into Magic URL style (e.g. -Aalpha or -N17 etc.)</returns> protected internal void toURL(StringBuilder htmlArgs, bool makePrintable) { if (!skipArg()) { String argValue = null, rangeStr = null; StorageAttribute attribute = StorageAttribute.NONE; bool isNull = false; PIC pic = null; NUM_TYPE num1, num2; Expression.ReturnValue retVal; int compIdx = 0; // Get the value and attribute and set the "is null" flag according // to the argument type switch (_type) { case ConstInterface.ARG_TYPE_VALUE: isNull = _valueIsNull; attribute = _valueAttr; argValue = _val; break; case ConstInterface.ARG_TYPE_EXP: retVal = _exp.evaluate(2000); argValue = retVal.mgVal; if (argValue == null) { isNull = true; } else { attribute = retVal.type; } compIdx = _exp.getTask().getCompIdx(); break; case ConstInterface.ARG_TYPE_FIELD: if (_fld.isNull()) { isNull = true; } else { argValue = _fld.getValue(false); attribute = _fld.getType(); } compIdx = _fld.getTask().getCompIdx(); break; case ConstInterface.ARG_TYPE_SKIP: isNull = true; //#919535 If argument is skipped then pass NULL it will handled in server. break; } // Create the argument string if (isNull) { htmlArgs.Append(ConstInterface.REQ_ARG_NULL); } else { switch (attribute) { case StorageAttribute.NUMERIC: num1 = new NUM_TYPE(argValue); num2 = new NUM_TYPE(argValue); num1.round(0); if (NUM_TYPE.num_cmp(num1, num2) == 0) { pic = new PIC("" + UtilStrByteMode.lenB(argValue), StorageAttribute.ALPHA, compIdx); String numDispVal = num2.to_a(pic).Trim(); if (numDispVal.Length <= 9) { htmlArgs.Append(ConstInterface.REQ_ARG_NUMERIC + num2.to_a(pic).Trim()); } else { htmlArgs.Append(ConstInterface.REQ_ARG_DOUBLE + num2.to_double()); } } else { htmlArgs.Append(ConstInterface.REQ_ARG_DOUBLE + num2.to_double()); } break; case StorageAttribute.DATE: pic = new PIC(Manager.GetDefaultDateFormat(), attribute, compIdx); rangeStr = ""; htmlArgs.Append(ConstInterface.REQ_ARG_ALPHA); break; case StorageAttribute.TIME: pic = new PIC(Manager.GetDefaultTimeFormat(), attribute, compIdx); rangeStr = ""; htmlArgs.Append(ConstInterface.REQ_ARG_ALPHA); break; case StorageAttribute.ALPHA: // alpha strings are kept internally as Unicode, so fall through to unicode case... case StorageAttribute.UNICODE: pic = new PIC("" + UtilStrByteMode.lenB(argValue), attribute, compIdx); rangeStr = ""; /* TODO: Kaushal. this should be "-U". * "-U" is currently used for null value. */ htmlArgs.Append(ConstInterface.REQ_ARG_UNICODE); break; case StorageAttribute.BLOB: pic = new PIC("", attribute, compIdx); rangeStr = ""; char contentType = BlobType.getContentType(argValue); // ANSI blobs are later translated to Unicode if (contentType == BlobType.CONTENT_TYPE_UNICODE || contentType == BlobType.CONTENT_TYPE_ANSI) { htmlArgs.Append(ConstInterface.REQ_ARG_UNICODE); } else { htmlArgs.Append(ConstInterface.REQ_ARG_ALPHA); } break; case StorageAttribute.BLOB_VECTOR: pic = new PIC("", attribute, compIdx); rangeStr = ""; htmlArgs.Append(ConstInterface.REQ_ARG_ALPHA); //QCR 970794 appending eye catcher for vectors passed as arguments on hyperlink argValue = ConstInterface.MG_HYPER_ARGS + BlobType.removeBlobPrefix(argValue) + ConstInterface.MG_HYPER_ARGS; break; case StorageAttribute.BOOLEAN: pic = new PIC("5", attribute, compIdx); rangeStr = "TRUE,FALSE"; htmlArgs.Append(ConstInterface.REQ_ARG_LOGICAL); break; } if (attribute != StorageAttribute.NUMERIC) { string finalValue = StrUtil.rtrim(DisplayConvertor.Instance.mg2disp(argValue, rangeStr, pic, compIdx, false)); //QCR 970794 converting the url to a legal format htmlArgs.Append(makePrintable ? GUIManager.Instance.makeURLPrintable(finalValue) : finalValue); } } } }
/// <summary> /// returns the array of indice for an item in the list by comparing the mgVal to the linked value or (-1) if none was /// found /// </summary> /// <param name = "mgVal">the internal value to look for </param> /// <param name = "isVectorValue">Denotes whether the value in mgVal should be treated as a vector (true) or not (false).</param> /// <param name = "isNull">true if the value to look for is null </param> /// <param name = "extraVals">Additional values, prepended to the searched values.</param> /// <param name="extraNums">Additional numeric values to be prepended to the searched values.</param> /// <param name = "splitCommaSeperatedVals">to split the val on comma or not </param> public int[] getIndexOf(string mgVal, bool isVectorValue, bool isNull, string[] extraVals, NUM_TYPE[] extraNums, bool splitCommaSeperatedVals) { int result = NOT_FOUND; String tmpMgVal; NUM_TYPE ctrlNumVal; String trimmedVal; String[] vals = null; NUM_TYPE[] nums = null; int offset = 0; int firstFitMatchIdx = NOT_FOUND; int firstFitMatchLength = -1; int minLength = -1; String compStr = ""; int[] indice = null; string[] values = null; if (isNull) { int i = 0; indice = new int[1] { NOT_FOUND }; for (i = 0; _nullFlags != null && i < _nullFlags.Length; i++) { if (_nullFlags[i]) { indice[0] = i; break; } } return(indice); } if (!isVectorValue) { //split the comma separated values; if (splitCommaSeperatedVals) { values = mgVal.Split(new char[] { ',' }); } else { values = new string[] { mgVal } }; } else { VectorType vector = new VectorType(mgVal); values = vector.GetCellValues(); } indice = new int[values.Length]; for (int iCtr = 0; iCtr < values.Length; iCtr++) { //Initialize result. result = NOT_FOUND; firstFitMatchIdx = NOT_FOUND; tmpMgVal = values[iCtr]; if (_isNumericType || extraNums != null) { try { ctrlNumVal = new NUM_TYPE(tmpMgVal); } catch (IndexOutOfRangeException) { indice = new int[1]; indice[0] = NOT_FOUND; return(indice); } trimmedVal = tmpMgVal; } else { ctrlNumVal = null; trimmedVal = StrUtil.rtrim(tmpMgVal); } // Run two passes. First one on extra values, second one on values belonging to this object for (int i = 0; i < 2 && result == NOT_FOUND; i++) { switch (i) { case 0: vals = extraVals; nums = extraNums; offset = 0; break; case 1: default: if (_isNumericType || nums != null) { offset = (nums == null ? 0 : nums.Length); } else { offset = (vals == null ? 0 : vals.Length); } vals = _linkVals; nums = _numVals; break; } if (vals != null) { for (int j = 0; j < vals.Length && result == NOT_FOUND; j++) { if (_isNumericType || nums != null) { if (NUM_TYPE.num_cmp(ctrlNumVal, nums[j]) == 0 || (Object)tmpMgVal == (Object)vals[j] || tmpMgVal.Equals(vals[j])) { // the numeric type is found exactly result = j + offset; break; } } else { if (vals[j].Equals(tmpMgVal) || trimmedVal.Length > 0 && StrUtil.rtrim(vals[j]).Equals(trimmedVal)) { result = j + offset; break; } //If Magic sent us a blank value, and such a value exists in the "non DC range" select it. //QCR # 751037 - search for blank values even in the linked values array of the data control if (trimmedVal.Length == 0 && StrUtil.rtrim(vals[j]).Length == 0) { result = j + offset; break; } // save the first fitting result // fixed bug#: 935015, the comparison will be according to the min length of the data & the options if (result == NOT_FOUND && trimmedVal.Length > 0) { minLength = Math.Min(trimmedVal.Length, vals[j].Length); compStr = trimmedVal.Substring(0, minLength); if (compStr.Length > 0 && vals[j].StartsWith(compStr)) { // if there is a min length match, check if it is the first fit match. // eg: if list has a,aaa,aaaaa and field value is 'aa' then first fit match is 'aaa'. // if list is a,aaaaa,aaa and field value is 'aa' then first fit match is 'aaaaa'. // if first fit not found, then closest match is used (eg- if field value is // 'aaaaaaaaa' in both the above list, closest match would be 'aaaaa'). if (minLength > firstFitMatchLength) { firstFitMatchIdx = j + offset; firstFitMatchLength = minLength; } } } } } } } if (result == NOT_FOUND) { result = firstFitMatchIdx; } //store indice found in integer array. indice[iCtr] = result; } return(indice); }