internal static void AddError (FrameworkElement element, ValidationError error)
{
var errors = GetErrorsCore (element);
errors.Add (error);
if (errors.Count == 1)
SetHasError (element, true);
}
/// <summary>
/// Constructor
/// </summary>
internal ValidationErrorEventArgs(ValidationError validationError, ValidationErrorEventAction action)
{
Invariant.Assert(validationError != null);
RoutedEvent = Validation.ErrorEvent;
_validationError = validationError;
_action = action;
}
public static string CleanErrorMessage(ValidationError error)
{
if (error.Exception == null)
return error.ErrorContent.ToString();
if (error.Exception is TargetInvocationException)
return error.Exception.InnerException.Message;
return error.Exception.Message;
}
internal static void AddError (FrameworkElement element, ValidationError error)
{
var errors = GetErrorsCore (element);
errors.Add (error);
if (errors.Count == 1)
SetHasError (element, true);
var control = element as Control;
if (control != null)
control.UpdateValidationState (false);
}
// Based on exception handler from Josh Smith blog.
public void Handler(object sender, RoutedEventArgs e)
{
System.Windows.Controls.ValidationErrorEventArgs args = e as System.Windows.Controls.ValidationErrorEventArgs;
if (args.Error.RuleInError is System.Windows.Controls.ValidationRule)
{
if (ErrorContainer != null)
{
Tracer.LogValidation("ViewBase.Handler called for ValidationRule exception.");
// Only want to work with validation errors that are Exceptions because the business object has already recorded the business rule violations using IDataErrorInfo.
BindingExpression bindingExpression = args.Error.BindingInError as System.Windows.Data.BindingExpression;
Debug.Assert(bindingExpression != null);
string propertyName = bindingExpression.ParentBinding.Path.Path;
DependencyObject OriginalSource = args.OriginalSource as DependencyObject;
// Construct the error message.
string errorMessage = "";
ReadOnlyObservableCollection <System.Windows.Controls.ValidationError> errors = System.Windows.Controls.Validation.GetErrors(OriginalSource);
if (errors.Count > 0)
{
StringBuilder builder = new StringBuilder();
builder.Append(propertyName).Append(":");
System.Windows.Controls.ValidationError error = errors[errors.Count - 1];
{
if (error.Exception == null || error.Exception.InnerException == null)
{
builder.Append(error.ErrorContent.ToString());
}
else
{
builder.Append(error.Exception.InnerException.Message);
}
}
errorMessage = builder.ToString();
}
// Add or remove the validation error to the validation error collection.
Debug.Assert(args.Action == ValidationErrorEventAction.Added || args.Action == ValidationErrorEventAction.Removed);
StringBuilder errorID = new StringBuilder();
errorID.Append(args.Error.RuleInError.ToString());
if (args.Action == ValidationErrorEventAction.Added)
{
ErrorContainer.AddError(new ValidationToolkit.ValidationError(propertyName, errorID.ToString(), errorMessage));
}
else if (args.Action == ValidationErrorEventAction.Removed)
{
ErrorContainer.RemoveError(propertyName, errorID.ToString());
}
}
}
}
private void AddError(object validationSource, ValidationError error)
{
errors.Add(new Tuple<object, ValidationError>(validationSource, error));
if (validationSource is FrameworkElement)
{
((FrameworkElement)validationSource).Unloaded += ValidationSourceUnloaded;
}
else if (validationSource is FrameworkContentElement)
{
((FrameworkContentElement)validationSource).Unloaded += ValidationSourceUnloaded;
}
}
public void ShouldReturnTheErrorContentOfTheFirstItemInTheCollection()
{
ErrorConverter converter = new ErrorConverter();
List<ValidationError> errors = new List<ValidationError>();
ValidationError error = new ValidationError(new ExceptionValidationRule(), new object());
error.ErrorContent = "TestError";
errors.Add(error);
object result = converter.Convert(errors.AsReadOnly(), null, null, null);
Assert.AreEqual("TestError", result);
}
public void ShouldReturnTheInnerExceptionMessageOfATargetInvocationException()
{
ErrorConverter converter = new ErrorConverter();
List<ValidationError> errors = new List<ValidationError>();
ValidationError error = new ValidationError(new ExceptionValidationRule(), new object());
error.Exception = new TargetInvocationException(null, new Exception("TestError"));
errors.Add(error);
object result = converter.Convert(errors.AsReadOnly(), null, null, null);
Assert.AreEqual("TestError", result);
}
public SelectSourceView()
{
InitializeComponent();
this.Loaded += (s, e) =>
{
var monthExpr = this.SelectMonth.GetBindingExpression(ComboBox.SelectedValueProperty);
var monthErr = new ValidationError(new RequiredRule(), monthExpr);
Validation.MarkInvalid(monthExpr, monthErr);
var yearExpr = this.SelectYear.GetBindingExpression(ComboBox.SelectedValueProperty);
var yearErr = new ValidationError(new RequiredRule(), yearExpr);
Validation.MarkInvalid(yearExpr, yearErr);
};
}
private static bool IsScopeFor(this DependencyObject parent, ValidationError error)
{
var inputTypes = GetForInputTypes(parent as FrameworkElement);
if (inputTypes == null)
{
return false;
}
if (inputTypes.Contains(typeof(Scope)))
{
return true;
}
return inputTypes.Contains(error.Target());
}
/// <summary>
/// Método que verifica se o campo está vazio, deve ser vinculado com
/// LostFocus para ativa-lo
/// </summary>
public static void TextBox_LostFocus(object sender, RoutedEventArgs e)
{
TextBox textBox = (TextBox)sender;
if (textBox.Text == "")
{
ValidationError validationError =
new ValidationError(new ValidacaoNotNull(),
textBox.GetBindingExpression(TextBox.TextProperty));
validationError.ErrorContent = "O campo não pode ser nulo";
Validation.MarkInvalid(
textBox.GetBindingExpression(TextBox.TextProperty),
validationError);
}
}
// remove a validation error from the given element
internal static void RemoveValidationError(ValidationError validationError, DependencyObject targetElement, bool shouldRaiseEvent)
{
if (targetElement == null)
return;
ValidationErrorCollection validationErrors = GetErrorsInternal(targetElement);
if (validationErrors == null || validationErrors.Count == 0 || !validationErrors.Contains(validationError))
return;
bool isValid = (validationErrors.Count == 1); // about to remove the last error
if (isValid)
{
// instead of removing the last error, just discard the error collection.
// This sends out only one property-change event, instead of two.
// Any bindings to Errors[x] will appreciate the economy.
targetElement.ClearValue(HasErrorPropertyKey);
targetElement.ClearValue(ValidationErrorsInternalProperty);
if (shouldRaiseEvent)
{
OnValidationError(targetElement, validationError, ValidationErrorEventAction.Removed);
}
ShowValidationAdorner(targetElement, false);
}
else
{
// if it's not the last error, just remove it.
validationErrors.Remove(validationError);
if (shouldRaiseEvent)
{
OnValidationError(targetElement, validationError, ValidationErrorEventAction.Removed);
}
}
}
// add a validation error to the given element
internal static void AddValidationError(ValidationError validationError, DependencyObject targetElement, bool shouldRaiseEvent)
{
if (targetElement == null)
return;
bool wasValid;
ValidationErrorCollection validationErrors = GetErrorsInternal(targetElement);
if (validationErrors == null)
{
wasValid = true;
validationErrors = new ValidationErrorCollection();
validationErrors.Add(validationError);
targetElement.SetValue(Validation.ValidationErrorsInternalProperty, validationErrors);
}
else
{
wasValid = (validationErrors.Count == 0);
validationErrors.Add(validationError);
}
if (wasValid)
{
targetElement.SetValue(HasErrorPropertyKey, BooleanBoxes.TrueBox);
}
if (shouldRaiseEvent)
{
OnValidationError(targetElement, validationError, ValidationErrorEventAction.Added);
}
if (wasValid)
{
ShowValidationAdorner(targetElement, true);
}
}
void MaybeEmitError (object message, Exception exception)
{
// If we've databound to a DependencyObject we need to emit
// the error on the Mentor, if it has one.
var fe = Target as FrameworkElement ?? Target.Mentor;
if (fe == null) {
return;
}
if (message is string && (string) message == "")
message = null;
var oldError = CurrentError;
if (message != null)
CurrentError = new ValidationError (message, null);
else if (exception != null)
CurrentError = new ValidationError (null, exception);
else
CurrentError = null;
// We had an error and now we have a new error
if (oldError != null && CurrentError != null) {
Validation.AddError (fe, CurrentError);
Validation.RemoveError (fe, oldError);
if (Binding.NotifyOnValidationError) {
fe.RaiseBindingValidationError (new ValidationErrorEventArgs(ValidationErrorEventAction.Removed, oldError));
fe.RaiseBindingValidationError (new ValidationErrorEventArgs(ValidationErrorEventAction.Added, CurrentError));
}
} else if (oldError != null) {
Validation.RemoveError (fe, oldError);
if (Binding.NotifyOnValidationError)
fe.RaiseBindingValidationError (new ValidationErrorEventArgs(ValidationErrorEventAction.Removed, oldError));
} else if (CurrentError != null) {
Validation.AddError (fe, CurrentError);
if (Binding.NotifyOnValidationError)
fe.RaiseBindingValidationError (new ValidationErrorEventArgs(ValidationErrorEventAction.Added, CurrentError));
}
}
internal ValidationErrorEventArgs(ValidationErrorEventAction action, ValidationError error)
{
this.action = action;
this.error = error;
}
private void SetError(TextBox textBox, string error)
{
var textBoxBindingExpression = textBox.GetBindingExpression(TextBox.TextProperty);
if (textBoxBindingExpression == null) return;
ValidationError validationError =
new ValidationError(new RequiredValidationRule(),
textBoxBindingExpression) {ErrorContent = error};
Validation.MarkInvalid(
textBoxBindingExpression,
validationError);
}
private void dataGrid_CellValueChanged(object sender, Control.DataGridCellEditEndingEventArgs e)
{
if (e.EditAction == Control.DataGridEditAction.Commit)
{
WPFdataGrid.DataGridControl wPFdataGrid = elementHost1.Child as WPFdataGrid.DataGridControl;
var dataGridView = wPFdataGrid.grid;
Control.DataGridRow dataRow = e.Row as Control.DataGridRow;
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(dataRow.Item);
DataGridDetailsPresenter presenter = FindVisualChild <DataGridDetailsPresenter>(dataRow);
DataTemplate detail = presenter.ContentTemplate;
Int16.TryParse(properties["HP"].GetValue(dataRow.Item).ToString(), out Int16 HP);
Int16.TryParse(properties["Attack"].GetValue(dataRow.Item).ToString(), out Int16 Attack);
Int16.TryParse(properties["Defense"].GetValue(dataRow.Item).ToString(), out Int16 Defense);
Int16.TryParse(properties["SPAttack"].GetValue(dataRow.Item).ToString(), out Int16 SPAttack);
Int16.TryParse(properties["SPDefense"].GetValue(dataRow.Item).ToString(), out Int16 SPDefense);
Int16.TryParse(properties["Speed"].GetValue(dataRow.Item).ToString(), out Int16 Speed);
Int16 CapRate = 0;
Int16 ExpDrop = 0;
try
{
Control.DataGrid detailGrid = detail.FindName("details", presenter) as Control.DataGrid;
PropertyDescriptorCollection detailProperties = TypeDescriptor.GetProperties(detailGrid.Items.CurrentItem);
Int16.TryParse(detailProperties["CapRate"]?.GetValue(detailGrid.Items?.CurrentItem)?.ToString(), out CapRate);
Int16.TryParse(detailProperties["ExpDrop"]?.GetValue(detailGrid.Items?.CurrentItem)?.ToString(), out ExpDrop);
}
catch
{
using (Pokemon db = new Pokemon())
{
try
{
CapRate = db.PokemonBaseStats.Where(p => p.PName == properties["PName"].GetValue(dataRow.Item).ToString()).Single().PokemonCapRate.CapRate;
ExpDrop = db.PokemonBaseStats.Where(p => p.PName == properties["PName"].GetValue(dataRow.Item).ToString()).Single().PokemonCapRate.ExpDrop;
}
catch
{
CapRate = 0;
ExpDrop = 0;
}
}
}
pokemon = new PokemonBaseStat()
{
PName = properties["PName"].GetValue(dataRow.Item)?.ToString(),
HP = HP,
Attack = Attack,
Defense = Defense,
SPAttack = SPAttack,
SPDefense = SPDefense,
Speed = Speed,
Type1 = properties["Type1"].GetValue(dataRow.Item)?.ToString(),
Type2 = properties["Type2"].GetValue(dataRow.Item)?.ToString(),
PokemonCapRate = new PokemonCapRate()
{
PName = properties["PName"].GetValue(dataRow.Item)?.ToString(),
CapRate = CapRate,
ExpDrop = ExpDrop
}
};
ValidationContext validate = new ValidationContext(pokemon, null, null);
IList <ValidationResult> errors = new List <ValidationResult>();
if (!Validator.TryValidateObject(pokemon, validate, errors, true))
{
e.Cancel = true;
EventArgs.Cancel = true;
EventArgs.Error = null;
Control.DataErrorValidationRule validationRule = new Control.DataErrorValidationRule();
Control.ValidationError error = new Control.ValidationError(validationRule, dataRow.BindingGroup.BindingExpressions);
EventArgs.Error = $"{errors.First().ErrorMessage}";
error.ErrorContent = $"{errors.First().ErrorMessage}";
foreach (ValidationResult result in errors.Skip(1))
{
EventArgs.Error += $"\n{result.ErrorMessage}";
error.ErrorContent += $"\n{result.ErrorMessage}";
}
foreach (var binding in dataRow.BindingGroup.BindingExpressions)
{
Control.Validation.MarkInvalid(dataRow.BindingGroup.BindingExpressions.First(), error);
}
}
else
{
Control.DataErrorValidationRule validationRule = new Control.DataErrorValidationRule();
Control.ValidationError error = new Control.ValidationError(validationRule, dataRow.BindingGroup.BindingExpressions);
e.Cancel = false;
EventArgs.Cancel = false;
error.ErrorContent = null;
}
}
}
ValidationErrorEventArgs CreateValidationErrorEventArgs(ValidationError error, ValidationErrorEventAction action) {
ConstructorInfo constructor = typeof(ValidationErrorEventArgs).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(ValidationError), typeof(ValidationErrorEventAction) }, null);
return (ValidationErrorEventArgs)constructor.Invoke(new object[] { error, action });
}
private void detailGrid_CellValueChanged(object sender, Control.DataGridCellEditEndingEventArgs e)
{
if (e.EditAction == Control.DataGridEditAction.Commit)
{
WPFdataGrid.DataGridControl wPFdataGrid = elementHost1.Child as WPFdataGrid.DataGridControl;
var dataGridView = wPFdataGrid.grid;
Control.DataGridRow dataRow = e.Row as Control.DataGridRow;
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(dataRow.Item);
Int16.TryParse(properties["CapRate"]?.GetValue(dataRow.Item)?.ToString(), out Int16 CapRate);
Int16.TryParse(properties["ExpDrop"]?.GetValue(dataRow.Item)?.ToString(), out Int16 ExpDrop);
pokemonCapRate = new PokemonCapRate()
{
PName = properties["PName"].GetValue(dataRow.Item)?.ToString(),
CapRate = CapRate,
ExpDrop = ExpDrop
};
ValidationContext validate = new ValidationContext(pokemonCapRate, null, null);
IList <ValidationResult> errors = new List <ValidationResult>();
if (!Validator.TryValidateObject(pokemonCapRate, validate, errors, true))
{
e.Cancel = true;
EventArgs.Cancel = true;
EventArgs.Error = null;
Control.DataErrorValidationRule validationRule = new Control.DataErrorValidationRule();
Control.ValidationError error = new Control.ValidationError(validationRule, dataRow.BindingGroup.BindingExpressions);
EventArgs.Error = $"{errors.First().ErrorMessage}";
error.ErrorContent = $"{errors.First().ErrorMessage}";
foreach (ValidationResult result in errors.Skip(1))
{
EventArgs.Error += $"\n{result.ErrorMessage}";
error.ErrorContent += $"\n{result.ErrorMessage}";
}
foreach (var binding in dataRow.BindingGroup.BindingExpressions)
{
Control.Validation.MarkInvalid(dataRow.BindingGroup.BindingExpressions.First(), error);
}
}
else
{
Control.DataErrorValidationRule validationRule = new Control.DataErrorValidationRule();
Control.ValidationError error = new Control.ValidationError(validationRule, dataRow.BindingGroup.BindingExpressions);
e.Cancel = false;
EventArgs.Cancel = false;
error.ErrorContent = null;
pokemonCapRates.Add(pokemonCapRate);
}
}
}
internal ValidationErrorEventArgs (ValidationErrorEventAction action, ValidationError error)
{
this.action = action;
this.error = error;
}
void ValidateSearchText(object sender, RoutedEventArgs e)
{
var be = searchTextBox.GetBindingExpression(TextBox.TextProperty);
try {
Validation.ClearInvalid(be);
UpdateSearch();
} catch (SearchPatternException ex) {
var ve = new ValidationError(be.ParentBinding.ValidationRules[0], be, ex.Message, ex);
Validation.MarkInvalid(be, ve);
}
}
internal void RemoveValidationError(ValidationError validationError)
{
// remove the error from the target element
Validation.RemoveValidationError(validationError, TargetElement, NotifyOnValidationError);
// remove the error from the binding group's target element
BindingGroup bindingGroup = BindingGroup;
if (bindingGroup != null)
{
bindingGroup.RemoveValidationError(validationError);
}
}
internal void AddValidationError(ValidationError validationError)
{
// add the error to the target element
Validation.AddValidationError(validationError, TargetElement, NotifyOnValidationError);
// add the error to the binding group's target element
BindingGroup bindingGroup = BindingGroup;
if (bindingGroup != null)
{
bindingGroup.AddValidationError(validationError);
}
}
internal void UpdateValidationError(ValidationError validationError)
{
// the steps are carefully ordered to avoid going through a "no error"
// state while replacing one error with another
ValidationError oldValidationError = _validationError;
_validationError = validationError;
if (validationError != null)
{
AddValidationError(_validationError);
}
if (oldValidationError != null)
{
RemoveValidationError(oldValidationError);
}
}
static void OnValidationError(DependencyObject source, ValidationError validationError, ValidationErrorEventAction action)
{
ValidationErrorEventArgs args = new ValidationErrorEventArgs(validationError, action);
if (source is ContentElement)
((ContentElement)source).RaiseEvent(args);
else if (source is UIElement)
((UIElement)source).RaiseEvent(args);
else if (source is UIElement3D)
((UIElement3D)source).RaiseEvent(args);
}
// return the value for the initial data transfer. Specifically:
// normal case - return UnsetValue (we'll get the value from the source object)
// valid proposed value - return the proposed value
// invalid proposed value - two subcases:
// one-way binding - return default/fallback value
// two-way binding - retrun NullDataItem (meaning "don't transfer")
//
// In both subcases, adopt the validation errors discovered earlier.
// In the two-way subcase, instead of a source-to-target transfer, we set the
// the target property to the (saved) raw proposed value, as if the user
// had edited this property.
object GetInitialValue(DependencyObject target, out ValidationError error)
{
object proposedValue;
// find the binding group this binding would join if it were two-way (even if it isn't)
BindingGroup bindingGroup = RootBindingExpression.FindBindingGroup(true, ContextElement);
BindingGroup.ProposedValueEntry entry;
// get the proposed value from the binding group
if (bindingGroup == null ||
(entry = bindingGroup.GetProposedValueEntry(SourceItem, SourcePropertyName)) == null)
{
// no proposed value
error = null;
proposedValue = DependencyProperty.UnsetValue;
}
else
{
// adopt the validation error (possibly null)
error = entry.ValidationError;
if (IsReflective && TargetProperty.IsValidValue(entry.RawValue))
{
// two-way binding - set the target property directly
target.SetValue(TargetProperty, entry.RawValue);
proposedValue = NullDataItem;
bindingGroup.RemoveProposedValueEntry(entry);
}
else if (entry.ConvertedValue == DependencyProperty.UnsetValue)
{
// invalid proposed value - use fallback/default
proposedValue = UseFallbackValue();
}
else
{
// valid proposed value
proposedValue = entry.ConvertedValue;
}
// if this binding didn't take over responsibility for the proposed
// value, add it to the list of bindings using the proposed value
if (proposedValue != NullDataItem)
{
bindingGroup.AddBindingForProposedValue(this, SourceItem, SourcePropertyName);
}
}
return proposedValue;
}
/// <summary>
/// Validates all properties on the current data source.
/// </summary>
/// <returns>True if there are no errors displayed, otherwise false.</returns>
/// <remarks>
/// Note that only errors on properties that are displayed are included. Other errors, such as errors for properties that are not displayed,
/// will not be validated by this method.
/// </remarks>
public bool Validate()
{
bool isValid = true;
_firstInvalidElement = null;
if (this.DataContext is IDataErrorInfo)
{
List<Binding> allKnownBindings = ClearInternal();
// Now show all errors
foreach (Binding knownBinding in allKnownBindings)
{
string errorMessage = ((IDataErrorInfo)this.DataContext)[knownBinding.Path.Path];
if (errorMessage != null && errorMessage.Length > 0)
{
isValid = false;
// Display the error on any elements bound to the property
FindBindingsRecursively(
this.Parent,
delegate(FrameworkElement element, Binding binding, DependencyProperty dp)
{
if (knownBinding.Path.Path == binding.Path.Path)
{
BindingExpression expression = element.GetBindingExpression(dp);
ValidationError error = new ValidationError(new ExceptionValidationRule(), expression, errorMessage, null);
System.Windows.Controls.Validation.MarkInvalid(expression, error);
if (_firstInvalidElement == null)
{
_firstInvalidElement = element;
}
return;
}
});
}
}
}
return isValid;
}
ValidationError RunValidationRule(ValidationRule validationRule, object value, CultureInfo culture)
{
ValidationError error;
ValidationResult validationResult = validationRule.Validate(value, culture, this);
if (validationResult.IsValid)
{
error = null;
}
else
{
if (TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.Update))
{
TraceData.Trace(TraceEventType.Warning,
TraceData.ValidationRuleFailed(
TraceData.Identify(this),
TraceData.Identify(validationRule)));
}
error = new ValidationError(validationRule, this, validationResult.ErrorContent, null);
}
return error;
}
void ValidateSearchText()
{
if (searchTextBox == null)
return;
var be = searchTextBox.GetBindingExpression(TextBox.TextProperty);
try {
Validation.ClearInvalid(be);
UpdateSearch();
} catch (SearchPatternException ex) {
var ve = new ValidationError(be.ParentBinding.ValidationRules[0], be, ex.Message, ex);
Validation.MarkInvalid(be, ve);
}
}
internal override object ConvertProposedValue(object value)
{
object rawValue = value;
bool isExtendedTraceEnabled = TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.Update);
if (isExtendedTraceEnabled)
{
TraceData.Trace(TraceEventType.Warning,
TraceData.UpdateRawValue(
TraceData.Identify(this),
TraceData.Identify(value)));
}
Type sourceType = Worker.SourcePropertyType;
IValueConverter implicitConverter = null;
CultureInfo culture = GetCulture();
// apply user-defined converter
if (Converter != null)
{
if (!UseDefaultValueConverter)
{
// if there's a user-defined converter, call it without catching
// exceptions (bug 992237). It can return DependencyProperty.UnsetValue
// to indicate a failure to convert.
value = Converter.ConvertBack(value, sourceType, ParentBinding.ConverterParameter, culture);
if (IsDetached)
{
// user code detached the binding. Give up.
return Binding.DoNothing;
}
if (isExtendedTraceEnabled)
{
TraceData.Trace(TraceEventType.Warning,
TraceData.UserConvertBack(
TraceData.Identify(this),
TraceData.Identify(value)));
}
// chain in a default value converter if the returned value's type is not compatible with the sourceType
if (value != Binding.DoNothing && value != DependencyProperty.UnsetValue &&
!IsValidValueForUpdate(value, sourceType))
{
// the dynamic converter is shared between Transfer and Update directions
// once instantiated, DefaultValueConverters are kept in a lookup table, making swapping
// default value converters reasonably fast
implicitConverter = DynamicConverter;
}
}
else
{
implicitConverter = Converter;
}
}
// apply an implicit conversion, if needed. This can be
// a) null conversion
// b) type conversion
if (value != Binding.DoNothing && value != DependencyProperty.UnsetValue)
{
if (IsNullValue(value))
{
if (value == null || !IsValidValueForUpdate(value, sourceType))
{
if (Worker.IsDBNullValidForUpdate)
{
value = DBNull.Value;
}
else
{
value = NullValueForType(sourceType);
}
}
}
else if (implicitConverter != null)
{
// here we pass in the TargetElement, see NOTE of caution in TransferValue() why this is ok
value = ConvertBackHelper(implicitConverter, value, sourceType, this.TargetElement, culture);
if (isExtendedTraceEnabled)
{
TraceData.Trace(TraceEventType.Warning,
TraceData.DefaultConvertBack(
TraceData.Identify(this),
TraceData.Identify(value)));
}
}
}
if (isExtendedTraceEnabled)
{
TraceData.Trace(TraceEventType.Warning,
TraceData.Update(
TraceData.Identify(this),
TraceData.Identify(value)));
}
// if the conversion failed, signal a validation error
if (value == DependencyProperty.UnsetValue)
{
if (ValidationError == null)
{
ValidationError validationError = new ValidationError(ConversionValidationRule.Instance, this, SR.Get(SRID.Validation_ConversionFailed, rawValue), null);
UpdateValidationError(validationError);
}
}
return value;
}
void ShowValidateError(bool showError)
{
IsShowingMessage = showError;
if (ValidatesControl == null || !IsAdornerEnabled()) return;
var bindingExpression = ValidatesControl.GetBindingExpression(TextBox.TagProperty);
if (bindingExpression == null) return;
var opExpression = BindingOperations.GetBindingExpression(ValidatesControl, TextBox.TagProperty);
if (opExpression == null) return;
var validationError = new ValidationError(new ExceptionValidationRule(), opExpression);
if (showError)
{
validationError.ErrorContent = Text;
System.Windows.Controls.Validation.MarkInvalid(bindingExpression, validationError);
}
else
{
System.Windows.Controls.Validation.ClearInvalid(bindingExpression);
}
}
private void ProcessException(Exception ex, bool validate)
{
object filteredException = null;
ValidationError validationError = null;
// If there is not ExceptionFilter, then Wrap the
// exception in a ValidationError.
if (ExceptionFilterExists())
{
filteredException = CallDoFilterException(ex);
if (filteredException == null)
return;
validationError = filteredException as ValidationError;
}
// See if an ExceptionValidationRule is in effect
if (validationError == null && validate)
{
ValidationRule exceptionValidationRule = ExceptionValidationRule.Instance;
if (filteredException == null)
{
validationError = new ValidationError(exceptionValidationRule, this, ex.Message, ex);
}
else
{
validationError = new ValidationError(exceptionValidationRule, this, filteredException, ex);
}
}
if (validationError != null)
{
UpdateValidationError(validationError);
}
}
public static void MarkInvalid(System.Windows.Data.BindingExpressionBase bindingExpression, ValidationError validationError)
{
}
/// <summary>
/// Mark this BindingExpression as invalid. If the BindingExpression has been
/// explicitly marked invalid in this way, then it will remain
/// invalid until ClearInvalid is called or another transfer to the source validates successfully.
/// </summary>
public static void MarkInvalid(BindingExpressionBase bindingExpression, ValidationError validationError)
{
if (bindingExpression == null)
throw new ArgumentNullException("bindingExpression");
if (validationError == null)
throw new ArgumentNullException("validationError");
bindingExpression.UpdateValidationError(validationError);
}
/// <summary>
/// Validates all properties on the current data source.
/// </summary>
/// <returns>True if there are no errors displayed, otherwise false.</returns>
/// <remarks>
/// Note that only errors on properties that are displayed are included. Other errors, such as errors for properties that are not displayed,
/// will not be validated by this method.
/// </remarks>
protected bool Validate()
{
bool isValid = true;
_firstInvalidElement = null;
errorMessages = new List<string>();
BindingHelper.FindBindingsRecursively(Parent,
delegate(FrameworkElement element, Binding binding, DependencyProperty dp)
{
foreach (ValidationRule rule in binding.ValidationRules)
{
ValidationResult valid = rule.Validate(element.GetValue(dp), CultureInfo.CurrentUICulture);
if (!valid.IsValid)
{
if (isValid)
{
isValid = false;
_firstInvalidElement = element;
}
BindingExpression expression = element.GetBindingExpression(dp);
ValidationError error = new ValidationError(rule, expression, valid.ErrorContent, null);
Validation.MarkInvalid(expression, error);
string errorMessage = valid.ErrorContent.ToString();
if (!errorMessages.Contains(errorMessage))
errorMessages.Add(errorMessage);
}
}
});
return isValid;
}
public BubbleErrorValidationRule(ValidationError error)
{
_error = error;
}
