/// <inheritdoc/>
public override string ToString()
{
var sb = new StringBuilder();
if (StartOffset == RangeFieldOffset.FirstValue)
{
sb.Append("FIRST_VALUE ");
}
else if (StartOffset == RangeFieldOffset.AfterLastValue)
{
sb.Append("AFTER_LAST_VALUE ");
}
sb.Append(StartValue.ToString());
sb.Append(" -> ");
if (EndOffset == RangeFieldOffset.LastValue)
{
sb.Append("LAST_VALUE ");
}
else if (EndOffset == RangeFieldOffset.BeforeFirstValue)
{
sb.Append("BEFORE_FIRST_VALUE ");
}
sb.Append(EndValue.ToString());
return(sb.ToString());
}
public override int GetHashCode()
{
int hash = 1;
if (BadgeType != 0)
{
hash ^= BadgeType.GetHashCode();
}
if (Rank != 0)
{
hash ^= Rank.GetHashCode();
}
if (StartValue != 0)
{
hash ^= StartValue.GetHashCode();
}
if (EndValue != 0)
{
hash ^= EndValue.GetHashCode();
}
if (CurrentValue != 0D)
{
hash ^= CurrentValue.GetHashCode();
}
return(hash);
}
public override Xamarin.Forms.Animation CreateFarwardAnimation()
{
double A = 0, R = 0, G = 0, B = 0;
var Parent = new Xamarin.Forms.Animation((d) => Target.GetType().GetProperty(PropertyName).SetValue(Target, Xamarin.Forms.Color.FromRgba(R, G, B, A)), 0, 1, AnimationEasing);
Parent.Add(0, 1, new Xamarin.Forms.Animation(d =>
{
A = d;
}, Xamarin.Forms.Color.FromHex(StartValue.ToString()).A, Xamarin.Forms.Color.FromHex(EndValue.ToString()).A));
Parent.Add(0, 1, new Xamarin.Forms.Animation(d =>
{
R = d;
}, Xamarin.Forms.Color.FromHex(StartValue.ToString()).R, Xamarin.Forms.Color.FromHex(EndValue.ToString()).R));
Parent.Add(0, 1, new Xamarin.Forms.Animation(d =>
{
G = d;
}, Xamarin.Forms.Color.FromHex(StartValue.ToString()).G, Xamarin.Forms.Color.FromHex(EndValue.ToString()).G));
Parent.Add(0, 1, new Xamarin.Forms.Animation(d =>
{
B = d;
}, Xamarin.Forms.Color.FromHex(StartValue.ToString()).B, Xamarin.Forms.Color.FromHex(EndValue.ToString()).B));
return(Parent);
}
public virtual string ToOsbString(ExportSettings exportSettings)
{
var startTimeString = ((int)StartTime).ToString(exportSettings.NumberFormat);
var endTimeString = ((int)EndTime).ToString(exportSettings.NumberFormat);
var startValueString = StartValue.ToOsbString(exportSettings);
var endValueString = EndValue.ToOsbString(exportSettings);
if (startTimeString == endTimeString)
{
endTimeString = string.Empty;
}
string[] parameters =
{
Identifier, ((int)Easing).ToString(exportSettings.NumberFormat),
startTimeString, endTimeString, startValueString
};
var result = string.Join(",", parameters);
if (startValueString != endValueString)
{
result += "," + endValueString;
}
return(result);
}
public override int GetHashCode()
{
int hash = 1;
if (BadgeType != 0)
{
hash ^= BadgeType.GetHashCode();
}
if (Rank != 0)
{
hash ^= Rank.GetHashCode();
}
if (StartValue != 0)
{
hash ^= StartValue.GetHashCode();
}
if (EndValue != 0)
{
hash ^= EndValue.GetHashCode();
}
if (CurrentValue != 0D)
{
hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(CurrentValue);
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
/// <summary>
/// OnInitialized
/// </summary>
protected override void OnInitialized()
{
base.OnInitialized();
StartValue = Value.Start;
EndValue = Value.End;
if (StartValue == DateTime.MinValue)
{
StartValue = DateTime.Now;
}
if (EndValue == DateTime.MinValue)
{
EndValue = StartValue.AddMonths(1);
}
StartPlaceHolderText ??= Localizer[nameof(StartPlaceHolderText)];
EndPlaceHolderText ??= Localizer[nameof(EndPlaceHolderText)];
SeparateText ??= Localizer[nameof(SeparateText)];
ClearButtonText ??= Localizer[nameof(ClearButtonText)];
ConfirmButtonText ??= Localizer[nameof(ConfirmButtonText)];
DateFormat ??= Localizer[nameof(DateFormat)];
}
public IReadOnlyCollection <double> Evaluate(Bounds bounds, bool strict)
{
if (!bounds.IsProvided(StepValue?.RequiredBound ?? BoundType.None) ||
!bounds.IsProvided(StartValue.RequiredBound) || !bounds.IsProvided(EndValue.RequiredBound))
{
if (strict)
{
throw new ArgumentException("Required bound not provided.");
}
return(EmptyArray <double> .Instance);
}
var startValue = StartValue.Evaluate(bounds);
var endValue = EndValue.Evaluate(bounds);
if (strict)
{
if (!bounds.Check(startValue))
{
throw new ArgumentException($"Start value '{startValue}' exceed bounds {bounds}.");
}
if (!bounds.Check(endValue))
{
throw new ArgumentException($"End value '{endValue}' exceed bounds {bounds}.");
}
}
return(ArrayUtils.Doubles(startValue, true, endValue, true, StepValue?.Evaluate(bounds) ?? 1));
}
public override void OnSerialize(BinaryWriter stream, StringCacheTable cache)
{
base.OnSerialize(stream, cache);
StartValue.OnSerialize(stream);
EndValue.OnSerialize(stream);
}
/// <summary>
/// Información de depuración
/// </summary>
protected override string GetDebugInfo(int indent)
{
return(Environment.NewLine + base.GetIndent(indent) +
" Variable: " + IndexVariable.GetDebugInfo() +
" StartValue: " + StartValue.GetDebugInfo() + " StartValueRPN: " + StartValueRPN.GetDebugInfo() +
" EndValue: " + EndValue.GetDebugInfo() + " EndValueRPN: " + EndValueRPN.GetDebugInfo() +
" StepValue: " + StepValue.GetDebugInfo() + " StepValueRPN: " + StepValueRPN.GetDebugInfo());
}
/// <summary>
/// 点击 确认时调用此方法
/// </summary>
private async Task ClickTodayButton()
{
SelectedValue.Start = DateTime.Today;
SelectedValue.End = DateTime.Today;
StartValue = DateTime.Today;
EndValue = StartValue.AddMonths(1);
await ClickConfirmButton();
}
private async Task OnClickSidebarItem(DateTimeRangeSidebarItem item)
{
SelectedValue.Start = item.StartDateTime;
SelectedValue.End = item.EndDateTime;
StartValue = item.StartDateTime;
EndValue = StartValue.AddMonths(1);
await ClickConfirmButton();
}
internal void CreatePath()
{
var equals = EndValue != null && StartValue != null && StartValue.Equals(EndValue.Value);
if (EndValue != null && !equals)
{
Path = Utils.Utils.CreatePath(StartValue.Value, EndValue.Value, _pointKeyFrame.PathCp1, _pointKeyFrame.PathCp2);
}
}
public NumericUpDown()
{
InitializeComponent();
NUDTextBox.Text = StartValue.ToString();
MinValue = 0;
StartValue = 0;
NUDButtonUP.PreviewMouseLeftButtonUp += NUDButton_PreviewMouseLeftButtonUp;
NUDButtonDown.PreviewMouseLeftButtonUp += NUDButton_PreviewMouseLeftButtonUp;
}
public PathKeyframe(LottieComposition composition, Keyframe <Vector2?> keyframe)
: base(composition, keyframe.StartValue, keyframe.EndValue, keyframe.Interpolator, keyframe.StartFrame, keyframe.EndFrame)
{
var equals = EndValue != null && StartValue != null && StartValue.Equals(EndValue.Value);
if (EndValue != null && !equals)
{
Path = Utils.Utils.CreatePath(StartValue.Value, EndValue.Value, keyframe.PathCp1, keyframe.PathCp2);
}
}
/// <summary>
/// OnParametersSet 方法
/// </summary>
protected override void OnParametersSet()
{
base.OnParametersSet();
Value ??= new DateTimeRangeValue();
StartValue = Value.Start;
EndValue = Value.End;
if (StartValue == DateTime.MinValue)
{
StartValue = DateTime.Now;
}
if (EndValue == DateTime.MinValue)
{
EndValue = StartValue.AddMonths(1);
}
SelectedValue.Start = StartValue;
SelectedValue.End = EndValue;
StartPlaceHolderText ??= Localizer[nameof(StartPlaceHolderText)];
EndPlaceHolderText ??= Localizer[nameof(EndPlaceHolderText)];
SeparateText ??= Localizer[nameof(SeparateText)];
ClearButtonText ??= Localizer[nameof(ClearButtonText)];
ConfirmButtonText ??= Localizer[nameof(ConfirmButtonText)];
TodayButtonText ??= Localizer[nameof(TodayButtonText)];
DateFormat ??= Localizer[nameof(DateFormat)];
if (StartValue.ToString("yyyy-MM") == EndValue.ToString("yyyy-MM"))
{
StartValue = StartValue.AddMonths(-1);
}
if (SidebarItems == null)
{
SidebarItems = new DateTimeRangeSidebarItem[]
{
new DateTimeRangeSidebarItem {
Text = Localizer["Last7Days"], StartDateTime = DateTime.Today.AddDays(-7), EndDateTime = DateTime.Today
},
new DateTimeRangeSidebarItem {
Text = Localizer["Last30Days"], StartDateTime = DateTime.Today.AddDays(-30), EndDateTime = DateTime.Today
},
new DateTimeRangeSidebarItem {
Text = Localizer["ThisMonth"], StartDateTime = DateTime.Today.AddDays(1 - DateTime.Today.Day), EndDateTime = DateTime.Today.AddDays(1 - DateTime.Today.Day).AddMonths(1).AddDays(-1)
},
new DateTimeRangeSidebarItem {
Text = Localizer["LastMonth"], StartDateTime = DateTime.Today.AddDays(1 - DateTime.Today.Day).AddMonths(-1), EndDateTime = DateTime.Today.AddDays(1 - DateTime.Today.Day).AddDays(-1)
},
};
}
}
public string GetText()
{
if (_singleValue)
{
return(StartValue.ToString());
}
else
{
return(String.Format("{0} to {1}", StartValue, EndValue));
}
}
/// <summary>
/// Gets the information.
/// </summary>
/// <param name="dictionary">The dictionary to add the Information to.</param>
public void GetInformation(ref Dictionary <string, string> dictionary)
{
if (!string.IsNullOrEmpty(Formula.Expression))
{
dictionary.Add("%Info.Formula", Formula.Expression);
}
dictionary.Add("%CharacterSheet.StartValue", StartValue.ToString());
dictionary.Add("%CharacterSheet.Modifier", Modifier.ToString());
dictionary.Add("%CharacterSheet.Value", Value.ToString());
}
public override void StartKinetic(VisualPayload payload, Func <float, float> translateTimeToEffectProportion)
{
var labelVis = payload.VisualData.Bound.GetComponent <LabelVisualizer>();
var startValue = StartValue.GetFirstValue(payload.Data);
var endValue = EndValue.GetFirstValue(payload.Data);
var transitionTimeInverse = 1f / TransitionTime.GetFirstValue(payload.Data);;
var formatString = FormatString.GetFirstValue(payload.Data);
var startTime = Time.time;
var bound = payload.VisualData.Bound.CreateDependingBound("Lerp Value");
bound.transform.parent = payload.VisualData.Bound.transform.parent;
payload.VisualData.Bound.transform.parent = bound.transform;
var valueSatellite =
bound.gameObject.AddComponent <SetLabelSatellite>();
valueSatellite.LabelVis = labelVis;
var newPayload = new VisualPayload(payload.Data, new VisualDescription(bound));
valueSatellite.UpdateFunc = (label) =>
{
float proportion = (Time.time - startTime) * transitionTimeInverse;
if (proportion >= 1)
{
label.Text = string.Format(formatString, endValue);
valueSatellite.Cleanup();
return;
}
proportion = translateTimeToEffectProportion(proportion);
var currentValue = Mathf.Lerp(startValue, endValue, proportion);
label.Text = string.Format(formatString, currentValue);
};
valueSatellite.CleanupFunc = (label) =>
{
JobManager.Instance.StartJob(
Finished.Transmit(newPayload), jobName: "Kinetic Finished", startImmediately: true,
maxExecutionsPerFrame: 1);
};
//throw new NotImplementedException();
}
public override void Validate()
{
base.Validate();
if (StartValue.GetType() != typeof(int))
{
throw new Exception($"Invalid {nameof(StartValue)}.");
}
if (EndValue.GetType() != typeof(int))
{
throw new Exception($"Invalid {nameof(EndValue)}.");
}
}
public override string ToString()
{
var s = StartValue.ToString();
var e = EndValue.ToString();
if (IsRange)
{
return(s + RangeDelimiter + e);
}
if (EndValue.Status != DateStatus.Unknown && string.IsNullOrEmpty(e))
{
return(s);
}
return(s + IntervalDelimiter + e);
}
public string ToLogString()
{
var sb = new StringBuilder()
.AppendLine($"[{nameof(ParametersPack)}]")
.AppendLine($"AnalysisProgramName: '{AnalysisProgramName}'")
.AppendLine($"AlgorithmType: {AlgorithmType.ToLogString()}")
.AppendLine($"StartValue: '{StartValue.ToString()}'")
.AppendLine($"EndValue: '{EndValue.ToString()}'")
.AppendLine($"ExtrapolationSegmentValue: '{ExtrapolationSegmentValue.ToString()}'")
.AppendLine($"LaunchesNumber: '{LaunchesNumber.ToString()}'")
.AppendLine($"Step: '{Step.ToString()}'")
.AppendLine($"OutputFilenamePattern: '{OutputFilenamePattern}'")
.AppendLine($"CommonAnalysisFilenameSuffix: '{CommonAnalysisFilenameSuffix}'")
.AppendLine($"OutputFileExtension: '{OutputFileExtension}'");
return(sb.ToString());
}
/// <summary>
/// 点击 清除按钮调用此方法
/// </summary>
/// <returns></returns>
private async Task ClickClearButton()
{
Value = new DateTimeRangeValue();
if (ValueChanged.HasDelegate)
{
await ValueChanged.InvokeAsync(Value);
}
if (OnClearValue != null)
{
await OnClearValue(Value);
}
StartValue = DateTime.Today;
EndValue = StartValue.AddMonths(1);
SelectedValue.Start = DateTime.MinValue;
SelectedValue.End = DateTime.MinValue;
}
public bool Equals(IndexRange other)
{
if (IsNull && other.IsNull)
{
return(true);
}
if (IsNull && !other.IsNull)
{
return(false);
}
if (!IsNull && other.IsNull)
{
return(false);
}
return(StartValue.Equals(other.StartValue) &&
EndValue.Equals(other.EndValue) &&
StartOffset == other.StartOffset &&
EndOffset == other.EndOffset);
}
public override void Validate()
{
base.Validate();
_structStartValues = StartValue.ToString().Split(',');
_structEndValues = EndValue.ToString().Split(',');
foreach (var startValue in _structStartValues)
{
if (!double.TryParse(startValue.ToString(), out double _))
{
throw new Exception($"Invalid {nameof(StartValue)}.");
}
}
foreach (var endValue in _structEndValues)
{
if (!double.TryParse(endValue.ToString(), out double _))
{
throw new Exception($"Invalid {nameof(EndValue)}.");
}
}
if (_structStartValues.Length != _structEndValues.Length)
{
throw new Exception($"{nameof(StartValue)} and {nameof(EndValue)} has different structure.");
}
switch (_structStartValues.Length)
{
case 1:
case 2:
case 4:
break;
default:
throw new Exception($"Supported formats are 'double', 'double,double' and 'double,double,double,double'.");
}
}
private void NUDTextBox_TextChanged(object sender, TextChangedEventArgs e)
{
int number = 0;
if (NUDTextBox.Text != "")
{
if (!int.TryParse(NUDTextBox.Text, out number))
{
NUDTextBox.Text = StartValue.ToString();
}
}
if (number > MaxValue)
{
NUDTextBox.Text = MaxValue.ToString();
}
if (number < MinValue)
{
NUDTextBox.Text = MinValue.ToString();
}
NUDTextBox.SelectionStart = NUDTextBox.Text.Length;
NumericValue = int.Parse(NUDTextBox.Text);
}
/// <summary>
/// 속성 중 Attribute Node로 표현해야 한다.
/// </summary>
/// <param name="writer"></param>
public override void GenerateXmlAttributes(XmlWriter writer)
{
base.GenerateXmlAttributes(writer);
if (StartValue.HasValue)
{
writer.WriteAttributeString("startValue", StartValue.ToString());
}
if (EndValue.HasValue)
{
writer.WriteAttributeString("endValue", EndValue.ToString());
}
if (ShowOnTop.HasValue)
{
writer.WriteAttributeString("showOnTop", ShowOnTop.GetHashCode().ToString());
}
if (ValueOnRight.HasValue)
{
writer.WriteAttributeString("valueOnRight", ValueOnRight.GetHashCode().ToString());
}
}
/// <summary>
/// Export to XML document
/// </summary>
/// <param name="doc">xml document</param>
/// <param name="parent">parent xml element</param>
public override void ExportToXML(ref XmlDocument doc, XmlElement parent)
{
XmlElement brk = doc.CreateElement("Break");
XmlAttribute caption = doc.CreateAttribute("Caption");
XmlAttribute startValue = doc.CreateAttribute("StartValue");
XmlAttribute endValue = doc.CreateAttribute("EndValue");
XmlAttribute color = doc.CreateAttribute("Color");
XmlAttribute isNoData = doc.CreateAttribute("IsNoData");
caption.InnerText = Caption;
startValue.InnerText = StartValue.ToString();
endValue.InnerText = EndValue.ToString();
color.InnerText = ColorTranslator.ToHtml(Color);
isNoData.InnerText = IsNoData.ToString();
brk.Attributes.Append(caption);
brk.Attributes.Append(startValue);
brk.Attributes.Append(endValue);
brk.Attributes.Append(color);
brk.Attributes.Append(isNoData);
parent.AppendChild(brk);
}
public string GetPropertiesAsXml()
{
StringBuilder sbResult = new StringBuilder();
sbResult.Append("<" + (String.IsNullOrEmpty(ColumnName) ? "_" : ColumnName) + GetRegexProperties());
if (!String.IsNullOrEmpty((PrecedingRegEx ?? "").TrimEnd('"')))
{
sbResult.Append(" Prefix = '" + PrecedingRegEx + "'");
}
if (!String.IsNullOrEmpty((TrailingRegEx ?? "").TrimEnd('"')))
{
sbResult.Append(" Suffix = '" + TrailingRegEx + "'");
}
if (ColumnType != RegexColumnType.STRING)
{
sbResult.Append(" Type = '" + ColumnType.ToString() + "'");
}
if (!String.IsNullOrEmpty(ValueMatchingCondition))
{
sbResult.Append(" Condition = '" + ValueMatchingCondition + "'");
}
if (AutoIncrement)
{
sbResult.Append(" AutoIncrement = '" + AutoIncrement.ToString() + "'");
}
if (AutoIncrement)
{
sbResult.Append(" StartValue = '" + StartValue.ToString() + "'");
}
if (AutoIncrement)
{
sbResult.Append(" Increment = '" + Increment.ToString() + "'");
}
if (!String.IsNullOrEmpty(Expression))
{
sbResult.Append(" Expression = '" + Expression + "'");
}
if (IsForeignKey)
{
sbResult.Append(" ForeignKey = '" + IsForeignKey.ToString() + "'");
}
if (IsUnique)
{
sbResult.Append(" PrimaryKey = '" + IsUnique.ToString() + "'");
}
if (!String.IsNullOrEmpty(DisplayName))
{
sbResult.Append(" DisplayName = '" + DisplayName + "'");
}
if (!String.IsNullOrEmpty(Description))
{
sbResult.Append(" Description = '" + Description + "'");
}
if (!String.IsNullOrEmpty(Default))
{
sbResult.Append(" Default = '" + Default + "'");
}
sbResult.Append(" />");
return(sbResult.ToString());
}
/// <summary>
/// 判断是否值相等
/// </summary>
/// <param name="obj"></param>
/// <returns>值相等，返回true</returns>
public override bool Equals(object obj)
{
bool result = false;
FromStartValueToEndValueReadEvent <TValue> other = obj as FromStartValueToEndValueReadEvent <TValue>;
result = object.ReferenceEquals(this, other) || (base.Equals(obj) && other != null && StartValue.Equals(other.StartValue) && EndValue.Equals(other.EndValue));
return(result);
}
/// <summary>
/// 获取哈希值
/// </summary>
/// <returns>返回哈希值</returns>
public override int GetHashCode()
{
return(base.GetHashCode() | StartValue.GetHashCode() | EndValue.GetHashCode());
}
