protected override string FormatList(List <string> digitText)
{
var result = string.Empty;
var inputList = digitText.Where(i => !string.IsNullOrEmpty(i)).ToList();
if (inputList.Count == 1)
{
return(inputList.FirstOrDefault()?.Trim());
}
foreach (var item in inputList)
{
if (!string.IsNullOrEmpty(item))
{
if (item.ToLower().EndsWith("ty"))
{
result += item.Trim() + "-";
}
else
{
result += item.Trim() + DecimalSeparator;
}
}
}
result = result.Trim().EndsWith("-") ? result.Trim().Remove(result.Trim().Length - 1) : result.Trim();
result = result.ToLower().Trim().EndsWith(DecimalSeparator.Trim()) ? result.Trim().Remove(result.Trim().Length - 3) : result.Trim();
return(result.Trim());
}
public PrintBlochSettings(bool printSpaces, bool trailingZeros, int decimalSpaces,
DecimalSeparator decimalSeparator, ImaginaryUnit imaginaryUnit)
{
this._printSpaces = printSpaces;
this._trailingZeros = trailingZeros;
this._decimalSpaces = decimalSpaces;
this._decimalSeparator = decimalSeparator;
this._imaginaryUnit = imaginaryUnit;
}
private (string integerPart, string fractionalPart) SeparateDecimal()
{
decimal decimalValue;
if (Value is decimal d)
{
decimalValue = d;
}
else if (Value is string value)
{
if (decimal.TryParse(value, out var @decimal))
{
decimalValue = @decimal;
}
else
{
return(value ?? "", "");
}
}
else
{
decimalValue = Convert.ToDecimal(Value, CultureInfo.InvariantCulture);
}
var intValue = (int)decimalValue;
var intString = intValue == 0 ? (decimalValue >= 0 ? "0" : "-0") : intValue.ToString($"###{GroupSeparator}###", CultureInfo.InvariantCulture);
decimalValue = Math.Abs(decimalValue - intValue);
var fractionalPart = "";
if (decimalValue == 0 && Precision > 0)
{
fractionalPart = DecimalSeparator.PadRight(Precision + 1, '0');
}
if (decimalValue != 0)
{
if (Precision <= 0)
{
fractionalPart = decimalValue.ToString(CultureInfo.InvariantCulture)
.Replace("0.", DecimalSeparator, true, CultureInfo.InvariantCulture);
}
else
{
decimalValue = Math.Round(decimalValue, Precision);
fractionalPart = decimalValue.ToString(CultureInfo.InvariantCulture)
.Replace("0.", DecimalSeparator, true, CultureInfo.InvariantCulture)
.PadRight(Precision + 1, '0');
}
}
return(intString, fractionalPart);
}
private string CalculateAdjustmentAmount(double aamount)
{
string adjustAmount = aamount.ToString();
string initialValue = adjustAmount;
if (adjustAmount.Contains(DecimalSeparator))
{
string[] tmpStrArr = adjustAmount.Split(DecimalSeparator.ToCharArray());
if (tmpStrArr.Length < 2)
{
return(adjustAmount);
}
if (!string.IsNullOrEmpty(tmpStrArr[1]) && tmpStrArr[1].Length > 2)
{
adjustAmount = String.Format("{0:c}", initialValue.Replace(GroupSeparator, ""));
}
else if (tmpStrArr[0].Length > 12)
{
adjustAmount = initialValue;
}
else if (string.IsNullOrEmpty(tmpStrArr[0]))
{
adjustAmount = initialValue;
}
double amount = Convert.ToDouble(adjustAmount);
int decimalCount = tmpStrArr[1].Length > 2 ? 2 : tmpStrArr[1].Length;
adjustAmount = string.Format("{0:c" + decimalCount + "}", amount) +
(adjustAmount.EndsWith(DecimalSeparator) ? DecimalSeparator : string.Empty);
adjustAmount = RemoveCurrencySymbol(adjustAmount, false);
if (!adjustAmount.Contains(DecimalSeparator))
{
return(initialValue);
}
else
{
return(adjustAmount);
}
}
else
{
if (adjustAmount.Length > 12)
{
adjustAmount = initialValue.Replace(GroupSeparator, string.Empty);
}
double amount = Convert.ToDouble(adjustAmount);
adjustAmount = amount.ToString();
return(CleanNetTotal(RemoveCurrencySymbol(String.Format("{0:c0}", amount), false), false));
}
}
public string ToJson()
{
var dict = new Dictionary <string, object>();
Symbol.SaveToDictionary(dict);
PositivePattern.SaveToDictionary(dict);
NegativePattern.SaveToDictionary(dict);
UseCustomSeparators.SaveToDictionary(dict);
DecimalSeparator.SaveToDictionary(dict);
GroupSeparator.SaveToDictionary(dict);
return(Json.Serialize(dict));
}
public override int GetHashCode()
{
unchecked
{
var hashCode = DisplaySymbol.GetHashCode();
hashCode = (hashCode * 397) ^ (IsoCode != null ? IsoCode.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ SymbolFirst.GetHashCode();
hashCode = (hashCode * 397) ^ (CurrencySymbol != null ? CurrencySymbol.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ DecimalDigits;
hashCode = (hashCode * 397) ^ (DecimalSeparator != null ? DecimalSeparator.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (GroupSeparator != null ? GroupSeparator.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ExampleFormat != null ? ExampleFormat.GetHashCode() : 0);
return(hashCode);
}
}
private string set_decimal_separator(string argument, DecimalSeparator separator)
{
if (separator == DecimalSeparator.dot)
{
if (argument.Contains(Constants.character.comma))
{
replace_comma_with_dot(ref argument);
}
}
else
{
if (argument.Contains(Constants.character.dot))
{
replace_dot_with_comma(ref argument);
}
}
return(argument);
}
internal void SetSeparatorStyle(SeparatorStyle style)
{
switch (style)
{
case SeparatorStyle.Dot:
DecimalSeparator = '.';
ArgumentSeparator = ',';
break;
default:
DecimalSeparator = ',';
ArgumentSeparator = ';';
break;
}
NumberFormat = new NumberFormatInfo();
NumberFormat.NumberDecimalSeparator = DecimalSeparator.ToString();
numberRegex = new Regex(NumberPattern);
}
public string[] FromJson(string json)
{
var dict = (Dictionary <string, object>)Json.Deserialize(json);
return(new[]
{
Symbol.LoadFromDictionary(dict),
PositivePattern.LoadFromDictionary(dict),
NegativePattern.LoadFromDictionary(dict),
UseCustomSeparators.LoadFromDictionary(dict),
DecimalSeparator.LoadFromDictionary(dict),
GroupSeparator.LoadFromDictionary(dict),
}
.Where(vr => vr.IsError())
.Select(vr => vr.Message)
.ToArray()
);
}
// ReSharper disable once ReturnTypeCanBeEnumerable.Global
public Data ReadDataFromFile(string path, int classCount)
{
var data = new Data();
var format = new NumberFormatInfo {
NumberDecimalSeparator = DecimalSeparator.ToString()
};
using (var file = new StreamReader(path))
{
for (var i = 0; i < SkipRows; i++)
{
file.ReadLine();
}
string line;
while ((line = file.ReadLine()) != null)
{
var parts = line.Split(Separator);
if (parts.Length == 0)
{
continue;
}
var row = parts.Select(part => Convert.ToDouble(part.Trim(), format)).ToList();
for (var j = 0; j < classCount; j++)
{
data.ObjectClass.Add(row.Last());
row.RemoveAt(row.Count - 1);
}
data.Attributes.Add(row);
}
}
if (Normalized)
{
Normalize(data);
}
return(data);
}
private DataItems GenerateDataItems()
{
return(new DataItems(
GameMode,
IsGameJoltPlayer ? "1" : "0",
GameJoltID.ToString(CultureInfo),
DecimalSeparator.ToString(),
Name,
LevelFile,
Position.ToP3DString(DecimalSeparator, CultureInfo),
Facing.ToString(CultureInfo),
Moving ? "1" : "0",
Skin,
BusyType,
PokemonVisible ? "1" : "0",
PokemonPosition.ToP3DString(DecimalSeparator, CultureInfo),
PokemonSkin,
PokemonFacing.ToString(CultureInfo)));
}
public override IList <string> GetFirsts()
{
var result = new StringList();
result.AddRange(Prefixes);
//we assume that prefix is always optional, so number can always start with plain digit
result.AddRange(new[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" });
// Python float numbers can start with a dot
if (IsSet(NumberOptions.AllowStartEndDot))
{
result.Add(DecimalSeparator.ToString());
}
if (IsSet(NumberOptions.AllowSign))
{
result.AddRange(new[] { "-", "+" });
}
return(result);
}
/// <inheritdoc/>
public override async Task SetParametersAsync(ParameterView parameters)
{
if (Rendered)
{
var decimalsChanged = isIntegerType ? false : parameters.TryGetValue <int>(nameof(Decimals), out var paramDecimals) && !Decimals.IsEqual(paramDecimals);
var decimalSeparatorChanged = parameters.TryGetValue <string>(nameof(DecimalSeparator), out var paramDecimalSeparator) && !DecimalSeparator.IsEqual(paramDecimalSeparator);
var alternativeDecimalSeparatorChanged = parameters.TryGetValue <string>(nameof(AlternativeDecimalSeparator), out var paramAlternativeDecimalSeparator) && !AlternativeDecimalSeparator.IsEqual(paramAlternativeDecimalSeparator);
var groupSeparatorChanged = parameters.TryGetValue <string>(nameof(GroupSeparator), out var paramGroupSeparator) && !GroupSeparator.IsEqual(paramGroupSeparator);
var groupSpacingChanged = parameters.TryGetValue <string>(nameof(GroupSpacing), out var paramGroupSpacing) && !GroupSpacing.IsEqual(paramGroupSpacing);
var currencySymbolChanged = parameters.TryGetValue <string>(nameof(CurrencySymbol), out var paramCurrencySymbol) && !CurrencySymbol.IsEqual(paramCurrencySymbol);
var currencySymbolPlacementChanged = parameters.TryGetValue <CurrencySymbolPlacement>(nameof(CurrencySymbolPlacement), out var paramCurrencySymbolPlacement) && !CurrencySymbolPlacement.IsEqual(paramCurrencySymbolPlacement);
var roundingMethodChanged = parameters.TryGetValue <NumericRoundingMethod>(nameof(RoundingMethod), out var paramRoundingMethod) && !RoundingMethod.IsEqual(paramRoundingMethod);
var minChanged = parameters.TryGetValue <TValue>(nameof(Min), out var paramMin) && !Min.IsEqual(paramMin);
var maxChanged = parameters.TryGetValue <TValue>(nameof(Max), out var paramMax) && !Max.IsEqual(paramMax);
var minMaxLimitsOverrideChanged = parameters.TryGetValue <NumericMinMaxLimitsOverride>(nameof(MinMaxLimitsOverride), out var paramMinMaxLimitsOverride) && !MinMaxLimitsOverride.IsEqual(paramMinMaxLimitsOverride);
var selectAllOnFocusChanged = parameters.TryGetValue <bool>(nameof(SelectAllOnFocus), out var paramSelectAllOnFocus) && !SelectAllOnFocus.IsEqual(paramSelectAllOnFocus);
var allowDecimalPaddingChanged = parameters.TryGetValue <NumericAllowDecimalPadding>(nameof(AllowDecimalPadding), out var paramAllowDecimalPadding) && !AllowDecimalPadding.IsEqual(paramAllowDecimalPadding);
var alwaysAllowDecimalSeparatorChanged = parameters.TryGetValue <bool>(nameof(AlwaysAllowDecimalSeparator), out var paramAlwaysAllowDecimalSeparator) && !AlwaysAllowDecimalSeparator.IsEqual(paramAlwaysAllowDecimalSeparator);
var modifyValueOnWheelChanged = parameters.TryGetValue <bool>(nameof(ModifyValueOnWheel), out var paramModifyValueOnWheel) && !ModifyValueOnWheel.IsEqual(paramModifyValueOnWheel);
var wheelOnChanged = parameters.TryGetValue <NumericWheelOn>(nameof(WheelOn), out var paramWheelOn) && !WheelOn.IsEqual(paramWheelOn);
if (decimalsChanged || decimalSeparatorChanged || alternativeDecimalSeparatorChanged ||
groupSeparatorChanged || groupSpacingChanged ||
currencySymbolChanged || currencySymbolPlacementChanged ||
roundingMethodChanged ||
minChanged || maxChanged ||
selectAllOnFocusChanged ||
allowDecimalPaddingChanged || alwaysAllowDecimalSeparatorChanged ||
modifyValueOnWheelChanged)
{
ExecuteAfterRender(async() => await JSModule.UpdateOptions(ElementRef, ElementId, new
{
Decimals = new { Changed = decimalsChanged, Value = GetDecimals() },
DecimalSeparator = new { Changed = decimalSeparatorChanged, Value = paramDecimalSeparator },
AlternativeDecimalSeparator = new { Changed = alternativeDecimalSeparatorChanged, Value = paramAlternativeDecimalSeparator },
GroupSeparator = new { Changed = groupSeparatorChanged, Value = paramGroupSeparator },
GroupSpacing = new { Changed = groupSpacingChanged, Value = paramGroupSpacing },
CurrencySymbol = new { Changed = currencySymbolChanged, Value = paramCurrencySymbol },
CurrencySymbolPlacement = new { Changed = currencySymbolPlacementChanged, Value = paramCurrencySymbolPlacement.ToCurrencySymbolPlacement() },
RoundingMethod = new { Changed = roundingMethodChanged, Value = paramRoundingMethod.ToNumericRoundingMethod() },
AllowDecimalPadding = new { Changed = allowDecimalPaddingChanged, Value = paramAllowDecimalPadding.ToNumericDecimalPadding() },
AlwaysAllowDecimalSeparator = new { Changed = alwaysAllowDecimalSeparatorChanged, Value = paramAlwaysAllowDecimalSeparator },
Min = new { Changed = minChanged, Value = paramMin },
Max = new { Changed = maxChanged, Value = paramMax },
MinMaxLimitsOverride = new { Changed = minMaxLimitsOverrideChanged, Value = paramMinMaxLimitsOverride },
SelectAllOnFocus = new { Changed = selectAllOnFocusChanged, Value = paramSelectAllOnFocus },
ModifyValueOnWheel = new { Changed = modifyValueOnWheelChanged, Value = paramModifyValueOnWheel },
WheelOn = new { Changed = wheelOnChanged, Value = paramWheelOn },
}));
}
var valueChanged = parameters.TryGetValue <TValue>(nameof(Value), out var paramValue) && !Value.IsEqual(paramValue);
if (valueChanged)
{
ExecuteAfterRender(async() => await JSModule.UpdateValue(ElementRef, ElementId, paramValue));
}
}
// This make sure we know that Min or Max parameters are defined and can be checked against the current value.
// Without we cannot determine if Min or Max has a default value when TValue is non-nullable type.
MinDefined = parameters.TryGetValue <TValue>(nameof(Min), out var min);
MaxDefined = parameters.TryGetValue <TValue>(nameof(Max), out var max);
await base.SetParametersAsync(parameters);
if (ParentValidation != null)
{
if (parameters.TryGetValue <Expression <Func <TValue> > >(nameof(ValueExpression), out var expression))
{
await ParentValidation.InitializeInputExpression(expression);
}
if (parameters.TryGetValue <string>(nameof(Pattern), out var pattern))
{
// make sure we get the newest value
var value = parameters.TryGetValue <TValue>(nameof(Value), out var inValue)
? inValue
: InternalValue;
await ParentValidation.InitializeInputPattern(pattern, value);
}
await InitializeValidation();
}
}
/// <summary>
/// Convert decimal to string according to the desired decimal separator
/// </summary>
/// <param name="value">Decimal value</param>
/// <param name="decimalSeparator">Separador desejado</param>
/// <returns>Retorna o decimal em formato de string com o separador de decimal desejado</returns>
public static string ReturnsStringWithDesiredDecimalSeparator(this decimal value, DecimalSeparator decimalSeparator = DecimalSeparator.Dot)
{
try
{
if (decimalSeparator == DecimalSeparator.Dot)
{
//To decimal be dotasso pass the culture as Invariant
return(value.ToString(CultureInfo.InvariantCulture.NumberFormat));
}
else
{
//To decimal be comma pass the culture as pt-BR
return(value.ToString(new CultureInfo("pt-BR")));
}
}
catch
{
return(value.ToString());
}
}
/// <summary>
/// Chart 설정 또는 변량에 대해 XML로 생성합니다.
/// </summary>
/// <param name="writer">xml writer</param>
public override void GenerateXmlAttributes(XmlWriter writer)
{
base.GenerateXmlAttributes(writer);
if (FormatNumber.HasValue)
{
writer.WriteAttributeString("FormatNumber", FormatNumber.Value.GetHashCode().ToString());
}
if (NumberPrefix.IsNotWhiteSpace())
{
writer.WriteAttributeString("NumberPrefix", NumberPrefix);
}
if (NumberSuffix.IsNotWhiteSpace())
{
writer.WriteAttributeString("NumberSuffix", NumberSuffix);
}
if (Decimals.HasValue)
{
writer.WriteAttributeString("Decimals", Decimals.Value.ToString());
}
if (ForceDecimals.HasValue)
{
writer.WriteAttributeString("ForceDecimals", ForceDecimals.Value.GetHashCode().ToString());
}
if (FormatNumberScale.HasValue)
{
writer.WriteAttributeString("FormatNumberScale", FormatNumberScale.Value.GetHashCode().ToString());
}
if (DefaultNumberScale.IsNotWhiteSpace())
{
writer.WriteAttributeString("DefaultNumberScale", DefaultNumberScale);
}
if (NumberScaleUnit.IsNotWhiteSpace())
{
writer.WriteAttributeString("NumberScaleUnit", NumberScaleUnit);
}
if (NumberScaleValue.IsNotWhiteSpace())
{
writer.WriteAttributeString("NumberScaleValue", NumberScaleValue);
}
if (ScaleRecursively.HasValue)
{
writer.WriteAttributeString("ScaleRecursively", ScaleRecursively.Value.GetHashCode().ToString());
}
if (MaxScaleRecursion.HasValue)
{
writer.WriteAttributeString("MaxScaleRecursion", MaxScaleRecursion.Value.ToString());
}
if (ScaleSeparator.IsNotWhiteSpace())
{
writer.WriteAttributeString("ScaleSeparator", ScaleSeparator);
}
if (DecimalSeparator.IsNotWhiteSpace())
{
writer.WriteAttributeString("DecimalSeparator", DecimalSeparator);
}
if (ThousandSeparator.IsNotWhiteSpace())
{
writer.WriteAttributeString("ThousandSeparator", ThousandSeparator);
}
if (InDecimalSeparator.IsNotWhiteSpace())
{
writer.WriteAttributeString("InDecimalSeparator", InDecimalSeparator);
}
if (InThousandSeparator.IsNotWhiteSpace())
{
writer.WriteAttributeString("InThousandSeparator", InThousandSeparator);
}
if (YAxisValueDecimals.HasValue)
{
writer.WriteAttributeString("yAxisValueDecimals", YAxisValueDecimals.Value.ToString());
}
}
public void AddDecimalSeparator(DecimalSeparator decimalSeparator)
{
var sepString = ((int)decimalSeparator).ToString();
this.codec.Add("sep2", sepString);
}
