internal AccelerationViewModel(Acceleration acceleration, Train train, MotorCar car)
{
CultureInfo culture = CultureInfo.InvariantCulture;
Entries = acceleration.Entries
.ToReadOnlyReactiveCollection(x => new EntryViewModel(x))
.AddTo(disposable);
SelectedEntryIndex = acceleration
.ToReactivePropertyAsSynchronized(
x => x.SelectedEntryIndex,
ignoreValidationErrorValue: true
)
.SetValidateNotifyError(x => x < 0 ? string.Empty : null)
.AddTo(disposable);
SelectedEntry = SelectedEntryIndex
.Select(x => x < 0 ? null : Entries[x])
.ToReadOnlyReactivePropertySlim()
.AddTo(disposable);
MinVelocity = acceleration
.ToReactivePropertyAsSynchronized(
x => x.MinVelocity,
x => x.ToString(culture),
x => double.Parse(x, NumberStyles.Float, culture),
ignoreValidationErrorValue: true
)
.AddTo(disposable);
MaxVelocity = acceleration
.ToReactivePropertyAsSynchronized(
x => x.MaxVelocity,
x => x.ToString(culture),
x => double.Parse(x, NumberStyles.Float, culture),
ignoreValidationErrorValue: true
)
.AddTo(disposable);
MinAcceleration = acceleration
.ToReactivePropertyAsSynchronized(
x => x.MinAcceleration,
x => x.ToString(culture),
x => double.Parse(x, NumberStyles.Float, culture),
ignoreValidationErrorValue: true
)
.AddTo(disposable);
MaxAcceleration = acceleration
.ToReactivePropertyAsSynchronized(
x => x.MaxAcceleration,
x => x.ToString(culture),
x => double.Parse(x, NumberStyles.Float, culture),
ignoreValidationErrorValue: true
)
.AddTo(disposable);
NowVelocity = acceleration
.ObserveProperty(x => x.NowVelocity)
.Select(x => $"{x} km/h")
.ToReadOnlyReactivePropertySlim()
.AddTo(disposable);
NowAcceleration = acceleration
.ObserveProperty(x => x.NowAcceleration)
.Select(x => $"{x} km/h/s")
.ToReadOnlyReactivePropertySlim()
.AddTo(disposable);
Resistance = acceleration
.ToReactivePropertyAsSynchronized(x => x.Resistance)
.AddTo(disposable);
ImageWidth = acceleration
.ToReactivePropertyAsSynchronized(
x => x.ImageWidth,
ignoreValidationErrorValue: true
)
.SetValidateNotifyError(x => x <= 0 ? string.Empty : null)
.AddTo(disposable);
ImageHeight = acceleration
.ToReactivePropertyAsSynchronized(
x => x.ImageHeight,
ignoreValidationErrorValue: true
)
.SetValidateNotifyError(x => x <= 0 ? string.Empty : null)
.AddTo(disposable);
Image = acceleration
.ObserveProperty(x => x.Image)
.ToReadOnlyReactivePropertySlim()
.AddTo(disposable);
new[]
{
acceleration
.PropertyChangedAsObservable()
.Where(x => x.PropertyName != nameof(acceleration.NowVelocity) &&
x.PropertyName != nameof(acceleration.NowAcceleration) &&
x.PropertyName != nameof(acceleration.Image)
)
.OfType <object>(),
acceleration.Entries.ObserveElementPropertyChanged().OfType <object>()
}
.Merge()
.ToReadOnlyReactivePropertySlim()
.Subscribe(_ => train.DrawAccelerationImage(car))
.AddTo(disposable);
ZoomIn = new ReactiveCommand();
ZoomIn.Subscribe(acceleration.ZoomIn).AddTo(disposable);
ZoomOut = new ReactiveCommand();
ZoomOut.Subscribe(acceleration.ZoomOut).AddTo(disposable);
Reset = new ReactiveCommand();
Reset.Subscribe(acceleration.Reset).AddTo(disposable);
MoveLeft = new ReactiveCommand();
MoveLeft.Subscribe(acceleration.MoveLeft).AddTo(disposable);
MoveRight = new ReactiveCommand();
MoveRight.Subscribe(acceleration.MoveRight).AddTo(disposable);
MoveBottom = new ReactiveCommand();
MoveBottom.Subscribe(acceleration.MoveBottom).AddTo(disposable);
MoveTop = new ReactiveCommand();
MoveTop.Subscribe(acceleration.MoveTop).AddTo(disposable);
MouseMove = new ReactiveCommand <InputEventModel.EventArgs>();
MouseMove.Subscribe(acceleration.MouseMove).AddTo(disposable);
MinVelocity
.SetValidateNotifyError(x =>
{
double min;
string message;
if (Utilities.TryParse(x, NumberRange.NonNegative, out min, out message))
{
double max;
if (Utilities.TryParse(MaxVelocity.Value, NumberRange.NonNegative, out max) && min >= max)
{
message = "MinはMax未満でなければなりません。";
}
}
return(message);
})
.Subscribe(_ => MaxVelocity.ForceValidate())
.AddTo(disposable);
MinVelocity.ObserveHasErrors
.ToReadOnlyReactivePropertySlim(mode: ReactivePropertyMode.DistinctUntilChanged)
.Where(x => !x)
.Subscribe(_ => MinVelocity.ForceNotify())
.AddTo(disposable);
MaxVelocity
.SetValidateNotifyError(x =>
{
double max;
string message;
if (Utilities.TryParse(x, NumberRange.NonNegative, out max, out message))
{
double min;
if (Utilities.TryParse(MinVelocity.Value, NumberRange.NonNegative, out min) && max <= min)
{
message = "MinはMax未満でなければなりません。";
}
}
return(message);
})
.Subscribe(_ => MinVelocity.ForceValidate())
.AddTo(disposable);
MaxVelocity.ObserveHasErrors
.ToReadOnlyReactivePropertySlim(mode: ReactivePropertyMode.DistinctUntilChanged)
.Where(x => !x)
.Subscribe(_ => MaxVelocity.ForceNotify())
.AddTo(disposable);
MinAcceleration
.SetValidateNotifyError(x =>
{
double min;
string message;
if (Utilities.TryParse(x, NumberRange.NonNegative, out min, out message))
{
double max;
if (Utilities.TryParse(MaxAcceleration.Value, NumberRange.NonNegative, out max) && min >= max)
{
message = "MinはMax未満でなければなりません。";
}
}
return(message);
})
.Subscribe(_ => MaxAcceleration.ForceValidate())
.AddTo(disposable);
MinAcceleration.ObserveHasErrors
.ToReadOnlyReactivePropertySlim(mode: ReactivePropertyMode.DistinctUntilChanged)
.Where(x => !x)
.Subscribe(_ => MinAcceleration.ForceNotify())
.AddTo(disposable);
MaxAcceleration
.SetValidateNotifyError(x =>
{
double max;
string message;
if (Utilities.TryParse(x, NumberRange.NonNegative, out max, out message))
{
double min;
if (Utilities.TryParse(MinAcceleration.Value, NumberRange.NonNegative, out min) && max <= min)
{
message = "MinはMax未満でなければなりません。";
}
}
return(message);
})
.Subscribe(_ => MinAcceleration.ForceValidate())
.AddTo(disposable);
MaxAcceleration.ObserveHasErrors
.ToReadOnlyReactivePropertySlim(mode: ReactivePropertyMode.DistinctUntilChanged)
.Where(x => !x)
.Subscribe(_ => MaxAcceleration.ForceNotify())
.AddTo(disposable);
}
public override int GetHashCode()
{
int hash = 1;
if (TotalPathLength != 0D)
{
hash ^= TotalPathLength.GetHashCode();
}
if (TotalTime != 0D)
{
hash ^= TotalTime.GetHashCode();
}
if (MatrixDimensionS != 0)
{
hash ^= MatrixDimensionS.GetHashCode();
}
if (MatrixDimensionT != 0)
{
hash ^= MatrixDimensionT.GetHashCode();
}
if (SpeedWeight != 0D)
{
hash ^= SpeedWeight.GetHashCode();
}
if (AccelWeight != 0D)
{
hash ^= AccelWeight.GetHashCode();
}
if (JerkWeight != 0D)
{
hash ^= JerkWeight.GetHashCode();
}
if (ObstacleWeight != 0D)
{
hash ^= ObstacleWeight.GetHashCode();
}
if (ReferenceWeight != 0D)
{
hash ^= ReferenceWeight.GetHashCode();
}
if (GoDownBuffer != 0D)
{
hash ^= GoDownBuffer.GetHashCode();
}
if (GoUpBuffer != 0D)
{
hash ^= GoUpBuffer.GetHashCode();
}
if (DefaultObstacleCost != 0D)
{
hash ^= DefaultObstacleCost.GetHashCode();
}
if (DefaultSpeedCost != 0D)
{
hash ^= DefaultSpeedCost.GetHashCode();
}
if (ExceedSpeedPenalty != 0D)
{
hash ^= ExceedSpeedPenalty.GetHashCode();
}
if (LowSpeedPenalty != 0D)
{
hash ^= LowSpeedPenalty.GetHashCode();
}
if (KeepClearLowSpeedPenalty != 0D)
{
hash ^= KeepClearLowSpeedPenalty.GetHashCode();
}
if (AccelPenalty != 0D)
{
hash ^= AccelPenalty.GetHashCode();
}
if (DecelPenalty != 0D)
{
hash ^= DecelPenalty.GetHashCode();
}
if (PositiveJerkCoeff != 0D)
{
hash ^= PositiveJerkCoeff.GetHashCode();
}
if (NegativeJerkCoeff != 0D)
{
hash ^= NegativeJerkCoeff.GetHashCode();
}
if (MaxAcceleration != 0D)
{
hash ^= MaxAcceleration.GetHashCode();
}
if (MaxDeceleration != 0D)
{
hash ^= MaxDeceleration.GetHashCode();
}
if (stBoundaryConfig_ != null)
{
hash ^= StBoundaryConfig.GetHashCode();
}
return(hash);
}
