/// <summary> /// Modifies the public fields values, of a target instance, with the values of another instance of the same type. /// Allows to indicate (true) whether the values must be compared in order to apply the change if them are different, /// else (false) the change will be forced for all. /// Returns whether any change -forced or not- was applied. /// </summary> public static bool AlterInstanceFields <TType>(ref TType Target, TType Source, bool ComparePriorToChange) { bool ChangeWasApplied = false; object TargetValue, SourceValue; if (ComparePriorToChange) { foreach (FieldInfo FieldData in typeof(TType).GetFields()) { TargetValue = FieldData.GetValue(Target); SourceValue = FieldData.GetValue(Source); if ((TargetValue != null && SourceValue != null && !TargetValue.Equals(SourceValue)) || (TargetValue == null && SourceValue != null) || (TargetValue != null && SourceValue == null)) { FieldData.SetValue(Target, SourceValue); ChangeWasApplied = true; } } } else { foreach (FieldInfo FieldData in typeof(TType).GetFields()) { FieldData.SetValue(Target, FieldData.GetValue(Source)); } ChangeWasApplied = true; } return(ChangeWasApplied); }
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e) { base.OnPropertyChanged(e); if (e.Property == TargetProperty && e.NewValue != null) { SetAttachedHelper(Target, this); SetBinding(Attached.Slider.ValueStringFormatProperty, new Binding { Source = e.NewValue, Path = new PropertyPath(Attached.Slider.ValueStringFormatProperty), Mode = BindingMode.OneWay }); SetBinding(TargetValueProperty, new Binding { Source = e.NewValue, Path = new PropertyPath(Slider.ValueProperty), Mode = BindingMode.OneWay }); } if (e.Property == Attached.Slider.ValueStringFormatProperty || e.Property == TargetValueProperty) { if (!String.IsNullOrEmpty(targetValueFormatString)) { FormattedValue = String.Format(targetValueFormatString, TargetValue); } else { FormattedValue = TargetValue.ToString(); } } }
public async Task <ActionResult <TargetValue> > PostTargetValue(TargetValue targetValue) { _context.TargetValue.Add(targetValue); await _context.SaveChangesAsync(); return(CreatedAtAction("GetTargetValue", new { id = targetValue.Id }, targetValue)); }
protected override void Initialize() { if (mapping == null) { mapping = new Dictionary <AnimatorControllerParameterType, ParameterType>(); foreach (string name in Enum.GetNames(typeof(AnimatorControllerParameterType))) { var acpt = (AnimatorControllerParameterType)Enum.Parse(typeof(AnimatorControllerParameterType), name, true); var pt = (ParameterType)Enum.Parse(typeof(ParameterType), name, true); mapping[acpt] = pt; } } if (memberType.IsA <string>()) { _value = new StringValue(member); } else if (memberType.IsA <int>()) { _value = new HashValue(member); } else //Assuming it is a AnimatorControllerParameter { _value = new ACPValue(member); } _mask = attribute.Filter; FetchVariables(); }
/// <summary> /// 保存客户经理的指标目标值 /// </summary> /// <param name="vals"></param> public void SaveManagerTargetValue(TargetVals vals) { if (vals != null && vals.TargetValues.Length > 0) { var valList = JSON.EncodeToEntity <List <TargetValueModel> >(vals.TargetValues); if (valList != null && valList.Count > 0) { foreach (var val in valList) { var tv = _TargetValueCase.FirstOrDefault(p => p.YearMonth == vals.Month && p.TargetId == val.TargetId && p.DistrictId == vals.DistrictId && p.TargetTagId == vals.TargetTagId && p.ManagerNo == val.ManagerNo); if (tv != null) { tv.TValue = val.TValue; } else { tv = new TargetValue { YearMonth = vals.Month, TargetTagId = vals.TargetTagId, DistrictId = vals.DistrictId, ManagerNo = val.ManagerNo, ManagerName = val.ManagerName, TargetId = val.TargetId, TValue = val.TValue, }; } _TargetValueCase.InsertOrUpdateAsync(tv); } } } }
public override CCodeExpression destroy_value(TargetValue value, bool is_macro_definition = false) { var type = value.value_type; if (type is ArrayType) { var array_type = (ArrayType)type; if (!array_type.fixed_length) { return(base.destroy_value(value, is_macro_definition)); } requires_array_free = true; var ccall = new CCodeFunctionCall(get_destroy_func_expression(type)); ccall = new CCodeFunctionCall(new CCodeIdentifier("_vala_array_destroy")); ccall.add_argument(get_cvalue_(value)); ccall.add_argument(get_ccodenode(array_type.length)); ccall.add_argument(new CCodeCastExpression(get_destroy_func_expression(array_type.element_type), "GDestroyNotify")); return(ccall); } else { return(base.destroy_value(value, is_macro_definition)); } }
/// <summary> /// This takes the name of another field in the model and that fields expected value. /// If the dependentProperty equals the targetValue then return valid. /// </summary> /// <param name="dependentProperty">The name of the field to check</param> /// <param name="targetValue">The expected value of the passed in field</param> public RequiredIfAttribute(object dependentProperty, object targetValue) { _innerAttribute = new RequiredAttribute(); this.DependentProperty = dependentProperty; this.TargetValue = targetValue; //If we have just a string then add it to an array. Otherwise if our object is already //an array then cast the object as an array if (DependentProperty.GetType().IsArray) { DependentPropertyArray = ((IEnumerable)DependentProperty).Cast <object>().Select(x => x.ToString()).ToArray(); } else if (DependentProperty.GetType().ToString() == "System.String") { String DependentPropertyString = (String)DependentProperty; DependentPropertyArray = new String[1] { DependentPropertyString }; } if (TargetValue.GetType().IsArray) { TargetValueArray = ((IEnumerable)TargetValue).Cast <object>().Select(x => x.ToString()).ToArray(); } else { TargetValueArray = new object[1] { TargetValue }; } }
public override CCodeExpression get_array_length_cvalue(TargetValue value, int dim = -1) { var array_type = value.value_type as ArrayType; if (array_type != null && array_type.fixed_length) { return(get_ccodenode(array_type.length)); } // dim == -1 => total size over all dimensions if (dim == -1) { if (array_type != null && array_type.rank > 1) { CCodeExpression cexpr = get_array_length_cvalue(value, 1); for (dim = 2; dim <= array_type.rank; dim++) { cexpr = new CCodeBinaryExpression(CCodeBinaryOperator.MUL, cexpr, get_array_length_cvalue(value, dim)); } return(cexpr); } else { dim = 1; } } List <CCodeExpression> size = ((GLibValue)value).array_length_cvalues; Debug.Assert(size != null && size.Count >= dim); return(size[dim - 1]); }
public override TargetValue copy_value(TargetValue value, CodeNode node) { var type = value.value_type; var cexpr = get_cvalue_(value); if (type is ArrayType) { var array_type = (ArrayType)type; if (!array_type.fixed_length) { return(base.copy_value(value, node)); } var temp_value = create_temp_value(type, false, node); var copy_call = new CCodeFunctionCall(new CCodeIdentifier(generate_array_copy_wrapper(array_type))); copy_call.add_argument(cexpr); copy_call.add_argument(get_cvalue_(temp_value)); ccode.add_expression(copy_call); return(temp_value); } else { return(base.copy_value(value, node)); } }
private void SetTypeAndVersion(string targetValue) { if (targetValue.StartsWith(TargetValuePrefix.Core, true, CultureInfo.InvariantCulture)) { Type = TargetType.Core; Version = targetValue.Substring(TargetValuePrefix.Core.Length); return; } if (targetValue.StartsWith(TargetValuePrefix.Standard, true, CultureInfo.InvariantCulture)) { Type = TargetType.Standard; Version = targetValue.Substring(TargetValuePrefix.Standard.Length); return; } if (targetValue.StartsWith(TargetValuePrefix.FrameworkNew, true, CultureInfo.InvariantCulture)) { Type = TargetType.Framework; Version = VersionNumberFormatter.Format(TargetValue.Substring(TargetValuePrefix.FrameworkNew.Length)); return; } if (targetValue.StartsWith(TargetValuePrefix.FrameworkOld, true, CultureInfo.InvariantCulture)) { Type = TargetType.Framework; Version = targetValue.Substring(TargetValuePrefix.FrameworkOld.Length); return; } throw new InvalidDotNetProjectException($"Could not determine {nameof(Type)} from '{targetValue}'."); }
/// <inheritdoc/> public string ToDelimitedString() { CultureInfo culture = CultureInfo.CurrentCulture; return(string.Format( culture, StringHelper.StringFormatSequence(0, 23, Configuration.FieldSeparator), Id, SubstanceIdentifier?.ToDelimitedString(), SubstanceStatus != null ? string.Join(Configuration.FieldRepeatSeparator, SubstanceStatus.Select(x => x.ToDelimitedString())) : null, SubstanceType?.ToDelimitedString(), InventoryContainerIdentifier?.ToDelimitedString(), ContainerCarrierIdentifier?.ToDelimitedString(), PositionOnCarrier?.ToDelimitedString(), InitialQuantity.HasValue ? InitialQuantity.Value.ToString(Consts.NumericFormat, culture) : null, CurrentQuantity.HasValue ? CurrentQuantity.Value.ToString(Consts.NumericFormat, culture) : null, AvailableQuantity.HasValue ? AvailableQuantity.Value.ToString(Consts.NumericFormat, culture) : null, ConsumptionQuantity.HasValue ? ConsumptionQuantity.Value.ToString(Consts.NumericFormat, culture) : null, QuantityUnits?.ToDelimitedString(), ExpirationDateTime.HasValue ? ExpirationDateTime.Value.ToString(Consts.DateTimeFormatPrecisionSecond, culture) : null, FirstUsedDateTime.HasValue ? FirstUsedDateTime.Value.ToString(Consts.DateTimeFormatPrecisionSecond, culture) : null, OnBoardStabilityDuration, TestFluidIdentifiers != null ? string.Join(Configuration.FieldRepeatSeparator, TestFluidIdentifiers.Select(x => x.ToDelimitedString())) : null, ManufacturerLotNumber, ManufacturerIdentifier?.ToDelimitedString(), SupplierIdentifier?.ToDelimitedString(), OnBoardStabilityTime?.ToDelimitedString(), TargetValue?.ToDelimitedString(), EquipmentStateIndicatorTypeCode?.ToDelimitedString(), EquipmentStateIndicatorValue?.ToDelimitedString() ).TrimEnd(Configuration.FieldSeparator.ToCharArray())); }
public override Expression BuildExpression(ParameterExpression pe, int indexPosition) { if (TargetValue.Count > 1) { var oexp1 = Expression.OrElse( Expression.Equal( Expression.ArrayIndex(pe, Expression.Constant(indexPosition)), Expression.Constant(TargetValue[0])), Expression.Equal( Expression.ArrayIndex(pe, Expression.Constant(indexPosition)), Expression.Constant(TargetValue[1]))); for (var c1 = 2; c1 < TargetValue.Count; c1++) { oexp1 = Expression.OrElse(oexp1, Expression.Equal( Expression.ArrayIndex(pe, Expression.Constant(indexPosition)), Expression.Constant(TargetValue[c1]))); } return(Expression.Not(oexp1)); } return(Expression.Not(Expression.Equal( Expression.ArrayIndex(pe, Expression.Constant(indexPosition)), Expression.Constant(TargetValue.First()) ))); }
/// <inheritdoc/> public override string ModelSummary() { using (StringWriter htmlWriter = new StringWriter()) { htmlWriter.Write("\r\n<div class=\"activityentry\">"); htmlWriter.Write(CLEMModel.DisplaySummaryValueSnippet(Metric, "Metric not set")); if (TargetValue > 0) { htmlWriter.Write("<span class=\"setvalue\">"); htmlWriter.Write(TargetValue.ToString("#,##0.##")); } else { htmlWriter.Write("<span class=\"errorlink\">VALUE NOT SET"); } htmlWriter.Write("</span> units per AE per day</div>"); if (OtherSourcesValue > 0) { htmlWriter.Write("\r\n<div class=\"activityentry\">"); htmlWriter.Write("<span class=\"setvalue\">" + OtherSourcesValue.ToString("#,##0.##") + "</span> is provided from sources outside the human food store</div>"); } return(htmlWriter.ToString()); } }
public async Task <IActionResult> PutTargetValue(int id, TargetValue targetValue) { if (id != targetValue.Id) { return(BadRequest()); } _context.Entry(targetValue).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TargetValueExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public override void store_local(LocalVariable local, TargetValue value, bool initializer, SourceReference source_reference = null) { if (!initializer && requires_destroy(local.variable_type)) { /* unref old value */ ccode.add_expression(destroy_local(local)); } store_value(get_local_cvalue(local), value, source_reference); }
public void ReCalcSendCost() { switch (this.CostSets) { case ArCostSets.Fate: { var nFCv = new ObservableCollection <BindableValue <int> >(); for (var i = 0; i < 5; i++) { nFCv.Add(new BindableValue <int>(0)); } nFCv[(int)ArResource.Fate].Value = -this.FateCost; this.SendingCost.ClearAllEvents(); this.SendingCost = new ArCost() { CostGroup = "Fate使用", CostName = FateType.Text(), Items = nFCv }; break; } case ArCostSets.Damage: { var nDCv = new ObservableCollection <BindableValue <int> >(); for (var i = 0; i < 5; i++) { nDCv.Add(new BindableValue <int>(0)); } nDCv[(int)TargetValue].Value = this.DamageCorrected; var nCostName = this.DamageBase.ToString("0;-0") + this.DefPoint.ToString("-0;+0;#") + this.DamageCorrect1.ToString("+0;-0;#") + this.DamageCorrect2.ToString("+0;-0;#"); //+ "=" //+ ((this.DamageType == ArDamageType.Heal) ? this.DamageCorrected.ToString("0;-0;0") : this.DamageCorrected.ToString("-0;0;0")); this.SendingCost.ClearAllEvents(); this.SendingCost = new ArCost() { CostGroup = (DamageType == ArDamageType.Heal ? TargetValue.ResourceName() : "") + DamageType.Text(), CostName = nCostName, Items = nDCv }; break; } case ArCostSets.SkillCost: { this.SendingCost = new ArCost(this.SelectedItem); break; } } this.SendingText = this.SendingCost.ToString(); this.CostChanged?.Invoke(this, null); }
public void SetsProperties() { var propInfo = typeof (SomeClass).GetProperties().First(); var testee = new TargetValue<SomeClass>(propInfo); Assert.AreEqual("A", testee.PropertyName); Assert.AreEqual(typeof(string), testee.ValueType); }
private void lst_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { if (TargetValue != null && TargetValue.Trim().Length > 0) { txt.Text = TargetValue; IsDropDownOpen = false; } FocusTextBox(); }
public void SetsProperties() { var propInfo = typeof(SomeClass).GetProperties().First(); var testee = new TargetValue <SomeClass>(propInfo); Assert.AreEqual("A", testee.PropertyName); Assert.AreEqual(typeof(string), testee.ValueType); }
public static void BeginAnimation(IAnimatable Item, DependencyProperty dp, AnimationTimeline ATL, object FromValue, object ToValue, Action OnCompleted, SetExtentAnimationTimelineDelegate SetExtentValue) { if (ToValue == null) { return; } if (Item != null && Item is DependencyObject) { ATL.FillBehavior = FillBehavior.HoldEnd; if (SetExtentValue != null) { SetExtentValue(ATL); } FillBehavior StatusValue = ATL.FillBehavior; ATL.FillBehavior = FillBehavior.Stop; DependencyObject ConvertItem = Item as DependencyObject; object TargetValue = null; if (StatusValue == FillBehavior.Stop || ATL.AutoReverse) { if (FromValue == null) { TargetValue = ConvertItem.GetValue(dp); } else { TargetValue = FromValue; } } else { TargetValue = ToValue; } ATL.Completed += new EventHandler( delegate(object sender, EventArgs e) { ConvertItem.SetValue(dp, TargetValue); object CurValue = ConvertItem.GetValue(dp); if (TargetValue != null && !TargetValue.Equals(CurValue)) { return; } if (OnCompleted != null) { OnCompleted(); } }); Item.BeginAnimation(dp, ATL, HandoffBehavior.SnapshotAndReplace); } }
/// <summary> /// Step the motor and return the resulting current value. /// </summary> /// <param name="timeStep"> The current timestep of the scene </param> public virtual Vector3 Step(float timeStep) { Vector3 errorValue, correctionValue; float decayFactor; // If the motor is not enabled, we assume that we // have reached the target value, so simply just // return the target value that we have if (!Enabled) { return(TargetValue); } // Calculate the difference in the current and target values errorValue = TargetValue - CurrentValue; correctionValue = Vector3.Zero; // If the calculated error value is not zero if (!ErrorIsZero(errorValue)) { // Calculate the error correction value // and add it to the current value correctionValue = StepError(timeStep, errorValue); CurrentValue += correctionValue; // The desired value reduces to zero which also reduces the // difference with current // If the decay timescale is not infinite, we decay if (TargetValueDecayTimeScale != PxMotor.Infinite) { decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep; TargetValue *= (1f - decayFactor); } } else { // Difference between what we have and target is small, Motor // is done if (TargetValue.ApproxEquals(Vector3.Zero, ErrorZeroThreshold)) { // The target can step down to nearly zero but not get // there If close to zero it is really zero TargetValue = Vector3.Zero; } // If the motor is done, set the current value to the target value CurrentValue = TargetValue; } // Update the last error as the most recently calculated error LastError = errorValue; return(correctionValue); }
public override void store_field(Field field, TargetValue instance, TargetValue value, SourceReference source_reference = null) { var lvalue = get_field_cvalue(field, instance); var type = lvalue.value_type; if (lvalue.actual_value_type != null) { type = lvalue.actual_value_type; } if (requires_destroy(type)) { /* unref old value */ ccode.add_expression(destroy_field(field, instance)); } store_value(lvalue, value, source_reference); }
// Compute the next step and return the new current value. // Returns the correction needed to move 'current' to 'target'. public virtual Vector3 Step(float timeStep) { if (!Enabled) { return(TargetValue); } Vector3 origTarget = TargetValue; // DEBUG Vector3 origCurrVal = CurrentValue; // DEBUG Vector3 correction = Vector3.Zero; Vector3 error = TargetValue - CurrentValue; if (!ErrorIsZero(error)) { correction = StepError(timeStep, error); CurrentValue += correction; // The desired value reduces to zero which also reduces the difference with current. // If the decay time is infinite, don't decay at all. float decayFactor = 0f; if (TargetValueDecayTimeScale != BSMotor.Infinite) { decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep; TargetValue *= (1f - decayFactor); } MDetailLog("{0}, BSVMotor.Step,nonZero,{1},origCurr={2},origTarget={3},timeStep={4},err={5},corr={6}", BSScene.DetailLogZero, UseName, origCurrVal, origTarget, timeStep, error, correction); MDetailLog("{0}, BSVMotor.Step,nonZero,{1},tgtDecayTS={2},decayFact={3},tgt={4},curr={5}", BSScene.DetailLogZero, UseName, TargetValueDecayTimeScale, decayFactor, TargetValue, CurrentValue); } else { // Difference between what we have and target is small. Motor is done. if (TargetValue.ApproxEquals(Vector3.Zero, ErrorZeroThreshold)) { // The target can step down to nearly zero but not get there. If close to zero // it is really zero. TargetValue = Vector3.Zero; } CurrentValue = TargetValue; MDetailLog("{0}, BSVMotor.Step,zero,{1},origTgt={2},origCurr={3},currTgt={4},currCurr={5}", BSScene.DetailLogZero, UseName, origCurrVal, origTarget, TargetValue, CurrentValue); } LastError = error; return(correction); }
public void AddValidation(ClientModelValidationContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } CheckForLocalizer(context); var errorMessage = GetErrorMessage(context.ModelMetadata.GetDisplayName()); MergeAttribute(context.Attributes, "data-val", "true"); MergeAttribute(context.Attributes, "data-val-requiredwhen", errorMessage); MergeAttribute(context.Attributes, "data-val-other", "#" + DependentProperty); MergeAttribute(context.Attributes, "data-val-otherval", TargetValue.ToString()); }
public override RandomValue GetRandomValue(int randomCount) { if (HasTargetValue()) { if (HasRangeValue()) { return(new RandomValueFromDoubleRangeWithTarget(ValueFrom.GetValueOrDefault(), ValueTo.GetValueOrDefault(), ValueDecimals, TargetValue.GetValueOrDefault(), TargetValueMinPercent.GetValueOrDefault(), randomCount)); } return(new RandomValueFromListWithTarget <double>(ValueList, TargetValue.GetValueOrDefault(), TargetValueMinPercent.GetValueOrDefault(), randomCount)); } if (HasRangeValue()) { return(new RandomValueFromDoubleRange(ValueFrom.GetValueOrDefault(), ValueTo.GetValueOrDefault(), ValueDecimals)); } return(new RandomValueFromList <double>(ValueList)); }
public void CreatesSetterExpression() { var propInfo = typeof(SomeClass).GetProperties().First(); var testee = new TargetValue <SomeClass>(propInfo); Expression <Func <SomeSourceClass, string> > getter = x => x.X; var expr = testee.CreateSetter(getter); var sourceInstance = new SomeSourceClass(); var targetInstance = new SomeClass(); (expr as Expression <Func <SomeClass, SomeSourceClass, SomeClass> >).Compile()(targetInstance, sourceInstance); Assert.AreEqual("a value", targetInstance.A); }
public void CreatesSetterExpression() { var propInfo = typeof(SomeClass).GetProperties().First(); var testee = new TargetValue<SomeClass>(propInfo); Expression<Func<SomeSourceClass, string>> getter = x => x.X; var expr = testee.CreateSetter(getter); var sourceInstance = new SomeSourceClass(); var targetInstance = new SomeClass(); (expr as Expression<Func<SomeClass, SomeSourceClass, SomeClass>>).Compile()(targetInstance, sourceInstance); Assert.AreEqual("a value", targetInstance.A); }
public override string GetCommandLineArguments() { ArgumentFormatter argFormatter = new ArgumentFormatter(); StringBuilder arguments = new StringBuilder(); arguments.Append(" " + argFormatter.GetFormattedArgument(Responses)); arguments.Append(" " + argFormatter.GetFormattedArgument(ResponseTransformation, false)); arguments.Append(" " + argFormatter.GetFormattedArgument(TargetValue.ToString(), false)); arguments.Append(" " + argFormatter.GetFormattedArgument(ConfidenceInterval)); arguments.Append(" " + argFormatter.GetFormattedArgument(NormalPlot)); arguments.Append(" " + argFormatter.GetFormattedArgument(Significance, false)); return(arguments.ToString().Trim()); }
/// <summary> /// Parse the target value(s), this also depends on the type of the value so it should be called no matter which /// changes /// </summary> private void ParseTargetValues() { _parsedTargetValues.Clear(); if (string.IsNullOrEmpty(TargetValue)) { return; } var parsedValues = from targetValue in TargetValue.Split(',') where !string.IsNullOrWhiteSpace(targetValue) select targetValue.Trim(); foreach (var parsedValue in parsedValues) { _parsedTargetValues.Add(parsedValue); } }
private void SetDescription() { switch (Type) { case TargetType.Framework: Description = _isOldStyleFormat ? $".NET Framework {TargetValue.Substring(TargetValuePrefix.FrameworkOld.Length)}" : $".NET Framework {VersionNumberFormatter.Format(TargetValue.Substring(TargetValuePrefix.FrameworkNew.Length))}"; break; case TargetType.Core: Description = $".NET Core {TargetValue.Substring(TargetValuePrefix.Core.Length)}"; break; case TargetType.Standard: Description = $".NET Standard {TargetValue.Substring(TargetValuePrefix.Standard.Length)}"; break; default: throw new InvalidOperationException($"Unhandled {nameof(TargetType)}: {Type}."); } }
void SetTargetValueEdit(TargetValueEdit targetValueEdit, TargetValue targetValue) { double multiplier = 1; if (targetValueEdit.Units == "%") { multiplier = 100.0; } targetValueEdit.Value = (targetValue.value * multiplier).ToString(); if (targetValue.absoluteVariance != 0) { targetValueEdit.Variance = targetValue.absoluteVariance.ToString(); } else { targetValueEdit.Variance = (100 * targetValue.relativeVariance).ToString() + "%"; } targetValueEdit.Binding = targetValue.targetBinding.ToString(); targetValueEdit.Drift = targetValue.drift.ToString(); targetValueEdit.Min = targetValue.min.ToString(); targetValueEdit.Max = targetValue.max.ToString(); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { // get a reference to the property this validation depends upon var containerType = validationContext.ObjectInstance.GetType(); var field = containerType.GetProperty(DependentProperty); if (field != null) { // get the value of the dependent property var dependentValue = field.GetValue(validationContext.ObjectInstance, null); // trim spaces of dependent value if (dependentValue != null && dependentValue is string) { dependentValue = (dependentValue as string).Trim(); if (!AllowEmptyStrings && (dependentValue as string).Length == 0) { dependentValue = null; } } // compare the value against the target value if ((dependentValue == null && TargetValue == null) || (dependentValue != null && (TargetValue.Equals("*") || dependentValue.Equals(TargetValue)))) { // match => means we should try validating this field if (!_innerAttribute.IsValid(value)) { // validation failed - return an error return(new ValidationResult(FormatErrorMessage(validationContext.DisplayName), new[] { validationContext.MemberName })); } } } return(ValidationResult.Success); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Finds the target. /// </summary> /// <param name="buildFile">The build file.</param> /// <param name="projectName">Name of the project.</param> /// <param name="fwroot">The fwroot.</param> /// <param name="projectPath">The project path.</param> /// ------------------------------------------------------------------------------------ private void FindTarget(ref string buildFile, ref string projectName, string fwroot, string projectPath) { lock(m_Targets) { string originalProjectName = projectName; bool fTargetExists = true; if (m_Targets.Contains(originalProjectName)) { TargetValue val = (TargetValue)m_Targets[originalProjectName]; if (val == null) fTargetExists = false; else { projectName = val.projectName; buildFile = val.buildfile; } } else { // If the target exists in the build file, we compile that. // If it doesn't exist, we look for a file '*.build' in the project's // directory and build with that. // If even that doesn't exist, we quit and let Visual Studio do the compile. // If the buildFile is the same as what we had before, we speed up things // and don't perform the check if ((buildFile == m_buildFile && Path.GetExtension(projectPath) == ".csproj") || TargetExists(buildFile, projectName, fwroot)) { // we already have the correct build file } else { if (projectPath != null && projectPath.Length > 0) { DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(projectPath)); FileInfo[] buildfiles = dirInfo.GetFiles("*.build"); string tmpBuildfile = string.Empty; if (buildfiles != null) { if (buildfiles.Length == 1) { // there is exactly one *.build file tmpBuildfile = buildfiles[0].FullName; } else if (buildfiles.Length > 1) { foreach (FileInfo fileInfo in buildfiles) { if (fileInfo.Name == "build.build") tmpBuildfile = fileInfo.FullName; } } } if (tmpBuildfile != string.Empty) { OutputBuild.WriteLine(string.Format("Target \"{2}\" not found in {0}, using {1} instead", buildFile, tmpBuildfile, projectName)); fwroot = Path.GetDirectoryName(Path.GetFullPath(projectPath)); if (!TargetExists(tmpBuildfile, projectName, fwroot)) projectName = "all"; buildFile = tmpBuildfile; // projectName = string.Format("{0} -D:fwroot=\"{1}\"", projectName, fwroot); } else { fTargetExists = false; } } else { fTargetExists = false; } } } if (fTargetExists) { m_Targets[originalProjectName] = new TargetValue(buildFile, projectName); } else { m_Targets[originalProjectName] = null; System.Diagnostics.Debug.WriteLine("Target doesn't exist"); OutputBuild.WriteLine(string.Format("Target \"{1}\" not found in {0}, performing VS build", buildFile, projectName)); throw new TargetException("Target doesn't exist"); } } }