protected virtual void OnErrorsChanged(DataErrorsChangedEventArgs e) { EventHandler<DataErrorsChangedEventArgs> handler = ErrorsChanged; if (handler != null) { handler(this, e); } }
protected virtual void OnErrorsChanged( DataErrorsChangedEventArgs e ) { if( ErrorsChanged != null ) { ErrorsChanged( this, e ); } }
private void MetadataProviderErrorsChanged(object sender, DataErrorsChangedEventArgs e) { EventHandler handler = CanExecuteChanged; if (handler != null) { handler(this, new EventArgs()); } }
protected virtual void OnErrorsChanged(DataErrorsChangedEventArgs args) { var handler = ErrorsChanged; if (handler != null) { handler(this, args); } }
private void sourceObject_ErrorsChanged(object sender, DataErrorsChangedEventArgs e) { var errors = _sourceObject.GetErrors(_sourceProperty) as IEnumerable<string>; if (errors != null && errors.Any()) { _target.Error = errors.First(); } else if (!string.IsNullOrEmpty(_target.Error)) { _target.Error = null; } }
private void ErrorsChangedCallback(object sender, DataErrorsChangedEventArgs args) { if (this.weakErrorsChangedListener == null) { return; } IErrorsChangedListener target = this.weakErrorsChangedListener.Target as IErrorsChangedListener; if (target == null) { this.Disconnect(); return; } target.OnErrorsChanged(sender, this.notifyChild, args); }
protected virtual void OnErrorsChanged(DataErrorsChangedEventArgs e) { this.ErrorsChanged?.Invoke(this, e); }
/// <summary> /// Handles the asynchronous INDEI errors that occur while the DataGrid is in editing mode. /// </summary> /// <param name="sender">INDEI item whose errors changed.</param> /// <param name="e">Error event arguments.</param> private void ValidationItem_ErrorsChanged(object sender, DataErrorsChangedEventArgs e) { INotifyDataErrorInfo indei = sender as INotifyDataErrorInfo; if (this._validationItems.ContainsKey(indei)) { Debug.Assert(this.EditingRow != null); // Determine the binding path. string bindingPath = this._validationItems[indei]; if (string.IsNullOrEmpty(bindingPath)) { bindingPath = e.PropertyName; } else if (!string.IsNullOrEmpty(e.PropertyName) && e.PropertyName.IndexOf(TypeHelper.LeftIndexerToken) >= 0) { bindingPath += TypeHelper.RemoveDefaultMemberName(e.PropertyName); } else { bindingPath += TypeHelper.PropertyNameSeparator + e.PropertyName; } // Remove the old errors. List<ValidationResult> validationResults = new List<ValidationResult>(); foreach (ValidationResult validationResult in this._validationResults) { ValidationResult oldValidationResult = this._indeiValidationResults.FindEqualValidationResult(validationResult); if (oldValidationResult != null && oldValidationResult.ContainsMemberName(bindingPath)) { this._indeiValidationResults.Remove(oldValidationResult); } else { validationResults.Add(validationResult); } } // Find any new errors and update the visuals. this.ValidateIndei(indei, e.PropertyName, bindingPath, null, validationResults, false /*wireEvents*/); this.UpdateValidationResults(validationResults, false /*scrollIntoView*/); // If we're valid now then reset our status. if (this.IsValid) { this.ResetValidationStatus(); } } else if (indei != null) { indei.ErrorsChanged -= new EventHandler<DataErrorsChangedEventArgs>(ValidationItem_ErrorsChanged); } }
private void _model_ErrorsChanged(object sender, DataErrorsChangedEventArgs e) { if (ErrorsChanged != null) ErrorsChanged(sender, e); }
void NotifyErrorsChanged (object o, DataErrorsChangedEventArgs e) { string property = ""; if (PropertyPathWalker.FinalNode.PropertyInfo != null) property = PropertyPathWalker.FinalNode.PropertyInfo.Name; Console.WriteLine ("Errors changed on: {0} / {1}", property, e.PropertyName); if (e.PropertyName == property) { var errors = CurrentNotifyError.GetErrors (property); if (errors != null) { var errorList = CurrentNotifyError.GetErrors (property).Cast <object> ().ToArray (); if (errorList.Length > 0) { foreach (var v in errorList) { MaybeEmitError (v, v as Exception); } } else { MaybeEmitError (null, null); } } else { MaybeEmitError (null, null); } } }
private void OnErrorsChanged(object sender, DataErrorsChangedEventArgs e) { // Notify the UI that the property has changed so that the validation error gets displayed (or removed). RaisePropertyChanged(e.PropertyName); }
void IErrorsChangedListener.OnErrorsChanged(object sender, bool notifyChild, DataErrorsChangedEventArgs e) { if (notifyChild) { this.NotifyChildDataErrorInfo_ErrorsChanged(sender, e); return; } this.NotifyDataErrorInfo_ErrorsChanged(sender, e); }
private void Vm_ErrorsChanged(object sender, System.ComponentModel.DataErrorsChangedEventArgs e) { Erori = new ObservableCollection <string>(Osoba.Errors.Errors.Values.SelectMany(x => x).ToList()); }
void OnErrorsChanged(object sender, DataErrorsChangedEventArgs e) { if (e.PropertyName == SourcePropertyName) { _host.OnDataErrorsChanged((INotifyDataErrorInfo)sender, e.PropertyName); } }
private void OnErrorsChanged(DataErrorsChangedEventArgs e) { var handler = this.ErrorsChanged; if (handler != null) handler(this, e); }
protected void OnErrorsChanged(DataErrorsChangedEventArgs e) { var handler = ErrorsChanged; if (handler != null) handler(this, e); }
private void NotifyChildDataErrorInfo_ErrorsChanged(object sender, DataErrorsChangedEventArgs e) { if (string.IsNullOrEmpty(e.PropertyName)) { this.NotifyOldDataErrorInfos(true); if (this.listener != null) { INotifyDataErrorInfo leafValue = this.listener.LeafValue as INotifyDataErrorInfo; if (leafValue != null) { this.NotifyNewDataErrorInfos(string.Empty, leafValue, true); } } } }
public void RaiseErrorsChanged(string propertyName) { EventHandler<DataErrorsChangedEventArgs> handler = ErrorsChanged; if (handler == null) return; var arg = new DataErrorsChangedEventArgs(propertyName); handler.Invoke(this, arg); }
public void RaiseErrorsChanged(DataErrorsChangedEventArgs args) { if (ErrorsChanged != null) { ErrorsChanged(this, args); } }
/// <summary> /// Called when the errors on the model have changed. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="System.ComponentModel.DataErrorsChangedEventArgs"/> instance containing the event data.</param> private void OnModelErrorsChanged(object sender, DataErrorsChangedEventArgs e) { var notifyDataErrorInfo = ((INotifyDataErrorInfo)_model); var errors = notifyDataErrorInfo.GetErrors(e.PropertyName); if (string.IsNullOrEmpty(e.PropertyName)) { HandleBusinessRuleErrors(errors); } else { HandleFieldErrors(e.PropertyName, errors); } Updated.SafeInvoke(this); }
private void OnErrorsChanged(object sender, DataErrorsChangedEventArgs e) { AllErrors = new ReadOnlyCollection<string>(SelectedPersonVM.GetAllErrors().Values.SelectMany(c => c).ToList()); }
private void RaiseCanExecuteChanged(object sender, DataErrorsChangedEventArgs dataErrorsChangedEventArgs) { SaveCommand.RaiseCanExecuteChanged(); }
/// <summary> /// Raises the <see cref="ErrorsChanged"/> event. /// </summary> /// <param name="e">The argument for the event.</param> protected virtual void OnErrorsChanged(DataErrorsChangedEventArgs e) { var handler = this.ErrorsChanged; if (handler != null) { handler(this, e); } }
// // Private Methods // // event handler for ErrorsChanged event private void OnErrorsChanged(object sender, DataErrorsChangedEventArgs args) { DeliverEvent(sender, args); }
private void NotifyDataErrorInfo_ErrorsChanged(object sender, DataErrorsChangedEventArgs e) { if (this.listener != null && this.listener.FullPathExists) { string empty = string.Empty; INotifyDataErrorInfo leafItem = this.listener.LeafItem as INotifyDataErrorInfo; if (leafItem != null) { empty = this.listener.LeafPropertyName; } if (string.CompareOrdinal(empty, e.PropertyName) == 0 || (e.PropertyName == null && empty == string.Empty)) { this.NotifyOldDataErrorInfos(false); this.NotifyNewDataErrorInfos(empty, leafItem, false); } } }
private void Vm_ErrorsChanged(object sender, System.ComponentModel.DataErrorsChangedEventArgs e) { //event koji ce se pozvati kad dodje do neispravne validacije //daj sve greske i pretvori ih u listu stringova da se mogu ispisati Erori = new ObservableCollection <string>(Kupac.Errors.Errors.Values.SelectMany(x => x).ToList()); }
void Receipt_ErrorsChanged(object sender, DataErrorsChangedEventArgs e) { RaisePropertyChanged("IsSaveEnabled"); }
void OnErrorsChanged(object sender, DataErrorsChangedEventArgs e) { // if notification was on the right thread, just do the work (normal case) if (Dispatcher.Thread == Thread.CurrentThread) { UpdateNotifyDataErrors(DependencyProperty.UnsetValue); } else if (!IsDataErrorsChangedPending) { // otherwise invoke an operation to do the work on the right context IsDataErrorsChangedPending = true; Engine.Marshal( (arg) => { UpdateNotifyDataErrors(DependencyProperty.UnsetValue); return null; }, null); } }
protected void OnDataErrorsChanged(DataErrorsChangedEventArgs e) { if (ErrorsChanged != null) { ErrorsChanged(_dataObject, e); } }
void OnErrorsChanged(object sender, DataErrorsChangedEventArgs e) { SubmitCommand.RaiseCanExecuteChanged(); }
// // Private Methods // // event handler for ErrorsChanged event private void OnErrorsChanged(object sender, DataErrorsChangedEventArgs args) { DeliverEvent(sender, args); }
void OpenItem_Errors(object sender, DataErrorsChangedEventArgs e) { OpenItemSearch openItem; openItem = sender as OpenItemSearch; if (openItem != null) { if (openItem.HasErrors) { AddErrorMessage(e.PropertyName + openItem.OpenItemID.ToString(), openItem.GetErrorMessage(e.PropertyName).FirstOrDefault()); } else { RemoveErrorMessage(e.PropertyName + openItem.OpenItemID.ToString()); } } }
public void DataErrorsChangedEventArgs_Test() { var propertyName = "abc"; var target = new DataErrorsChangedEventArgs(propertyName); Assert.AreEqual(propertyName, target.PropertyName); }