private IValidationErrors GetErrors(IValidationErrors result, RowPresenter rowPresenter, IColumns source, bool isAsync)
{
IReadOnlyDictionary <RowPresenter, IDataValidationErrors> dictionary = isAsync ? _asyncErrorsByRow : _errorsByRow;
if (dictionary != null)
{
IDataValidationErrors errors;
if (dictionary.TryGetValue(rowPresenter, out errors))
{
if (errors != null && errors.Count > 0)
{
result = GetErrors(result, rowPresenter, errors, source, !isAsync);
}
}
}
if (isAsync && rowPresenter == CurrentRow)
{
foreach (var asyncValidator in AsyncValidators)
{
var fault = asyncValidator.GetFault(source);
if (fault != null)
{
result = result.Add(fault);
}
}
}
return(result);
}
internal bool HasError(RowPresenter rowPresenter, IColumns source, bool isAsync)
{
IReadOnlyDictionary <RowPresenter, IDataValidationErrors> dictionary = isAsync ? _asyncErrorsByRow : _errorsByRow;
if (dictionary != null)
{
IDataValidationErrors errors;
if (dictionary.TryGetValue(rowPresenter, out errors))
{
if (errors != null && errors.Count > 0 && HasError(rowPresenter, errors, source, !isAsync))
{
return(true);
}
}
}
if (isAsync && rowPresenter == CurrentRow)
{
foreach (var asyncValidator in AsyncValidators)
{
if (asyncValidator.GetFault(source) != null)
{
return(true);
}
}
}
return(false);
}
private bool HasError(RowPresenter rowPresenter, IColumns columns)
{
if (ErrorsByRow.Count == 0)
{
return(false);
}
IDataValidationErrors errors;
if (!ErrorsByRow.TryGetValue(rowPresenter, out errors))
{
return(false);
}
for (int i = 0; i < errors.Count; i++)
{
var message = errors[i];
if (message.Source.SetEquals(columns))
{
return(true);
}
}
return(false);
}
private bool HasVisibleError(RowPresenter rowPresenter, bool isAsync)
{
IReadOnlyDictionary <RowPresenter, IDataValidationErrors> dictionary = isAsync ? _asyncErrorsByRow : _errorsByRow;
if (dictionary != null)
{
IDataValidationErrors errors;
if (dictionary.TryGetValue(rowPresenter, out errors))
{
if (errors != null && errors.Count > 0 && errors.Any(x => IsVisible(rowPresenter, x.Source)))
{
return(true);
}
}
}
if (isAsync && rowPresenter == CurrentRow)
{
if (AsyncValidators.Any(x => x.Status == AsyncValidatorStatus.Faulted))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Gets the flushing error.
/// </summary>
/// <param name="rowPresenter">The row presenter.</param>
/// <returns>The flushing error.</returns>
public FlushingError GetFlushingError(RowPresenter rowPresenter)
{
RowBinding rowBinding = RowBinding;
var element = rowBinding[rowPresenter];
return(element != null?GetFlushingError(element) : null);
}
/// <summary>
/// Gets the view element for specified <see cref="RowPresenter"/>.
/// </summary>
/// <param name="rowPresenter">The specified <see cref="RowPresenter"/>.</param>
/// <returns>The view element.</returns>
public UIElement this[RowPresenter rowPresenter]
{
get
{
if (Ordinal == -1)
{
return(null);
}
if (Parent != null)
{
return(Parent.GetChild(Parent[rowPresenter], Ordinal));
}
if (rowPresenter == null || rowPresenter.Template != Template)
{
return(null);
}
var rowView = rowPresenter.View;
if (rowView == null)
{
return(null);
}
var elements = rowView.Elements;
return(elements == null ? null : elements[Ordinal]);
}
}
/// <summary>
/// Begins inserting new row after specified row.
/// </summary>
/// <param name="row">The specified row. If <see langword="null"/>, insert at the end.</param>
public void BeginInsertAfter(RowPresenter row = null)
{
VerifyInsert(row);
SuspendInvalidateView();
RequireLayoutManager().BeginInsertAfter(null, row);
ResumeInvalidateView();
}
internal bool HasError(RowPresenter rowPresenter, Input <RowBinding, IColumns> input, bool?blockingPrecedence)
{
if (rowPresenter == CurrentRow)
{
var flushingError = GetFlushingError(input.Binding[rowPresenter]);
if (flushingError != null)
{
return(true);
}
}
if (blockingPrecedence.HasValue)
{
if (AnyBlockingErrorInput(rowPresenter, input, blockingPrecedence.Value))
{
return(false);
}
}
if (HasError(rowPresenter, input.Target, false))
{
return(true);
}
if (HasError(rowPresenter, input.Target, true))
{
return(true);
}
return(false);
}
private void ClearAsyncErrors(RowPresenter rowPresenter)
{
Debug.Assert(rowPresenter != null);
if (_asyncErrorsByRow != null && _asyncErrorsByRow.ContainsKey(rowPresenter))
{
_asyncErrorsByRow.Remove(rowPresenter);
}
}
internal void Refresh(T element, RowPresenter rowPresenter)
{
if (!IsFlushing && !IsLockedByFlushingError(element))
{
RowBinding.Refresh(element, rowPresenter);
}
element.RefreshValidation(GetValidationInfo(rowPresenter));
}
private void UpdateAsyncErrors(RowPresenter rowPresenter, IDataValidationErrors errors)
{
ClearAsyncErrors(rowPresenter);
if (errors.Count > 0)
{
AsyncErrorsByRow.Add(rowPresenter, errors);
}
}
private static void Refresh(Placeholder element, RowPresenter rowPresenter, double desiredWidth, double desiredHeight, Action <Placeholder, RowPresenter> onRefresh)
{
element.DesiredWidth = desiredWidth;
element.DesiredHeight = desiredHeight;
if (onRefresh != null)
{
onRefresh(element, rowPresenter);
}
}
internal void InsertChild(int index, RowPresenter child)
{
Debug.Assert(index >= 0 && index <= Children.Count);
if (_children == null)
{
_children = new List <RowPresenter>();
}
_children.Insert(index, child);
}
/// <summary>
/// Begins inserting child row after specified child row.
/// </summary>
/// <param name="child">The specified child row, <see langword="null"/> if insert as last child row.</param>
public void BeginInsertAfter(RowPresenter child = null)
{
VerifyInsert(child);
var elementManager = ElementManager;
elementManager?.SuspendInvalidateView();
RowManager.BeginInsertAfter(this, child);
elementManager?.ResumeInvalidateView();
}
internal sealed override void PerformSetup(RowPresenter rowPresenter)
{
Setup(SettingUpElement, rowPresenter);
Refresh(SettingUpElement, rowPresenter);
if (Input != null)
{
Input.Attach(SettingUpElement);
}
}
private bool Validate(RowPresenter rowPresenter, ref int errors, int errorLimit)
{
Debug.Assert(rowPresenter != null);
rowPresenter.Validate(false);
if (Errors.ContainsKey(rowPresenter))
{
errors++;
}
return(errors < errorLimit);
}
private static void SetRowPresenter(this UIElement element, RowPresenter value)
{
if (value == null)
{
element.ClearValue(RowPresenterProperty);
}
else
{
element.SetValue(RowPresenterProperty, value);
}
}
private void VerifyRowPresenter(RowPresenter value, string paramName, int index = -1)
{
if (value == null)
{
throw new ArgumentNullException(GetParamName(paramName, index));
}
if (value.DataPresenter != this || value.Index < 0)
{
throw new ArgumentException(DiagnosticMessages.DataPresenter_InvalidRowPresenter, GetParamName(paramName, index));
}
}
internal void ShowAll(RowPresenter rowPresenter)
{
if (_progress == null)
{
return;
}
if (_valueChanged.ContainsKey(rowPresenter))
{
_valueChanged.Remove(rowPresenter);
}
_progress[rowPresenter] = null;
}
private void VerifyInsert(RowPresenter row)
{
if (!CanInsert)
{
throw new InvalidOperationException(DiagnosticMessages.DataPresenter_VerifyCanInsert);
}
if (row != null)
{
if (row.DataPresenter != this || row.Parent != null)
{
throw new ArgumentException(DiagnosticMessages.DataPresenter_InvalidRowPresenter, nameof(row));
}
}
}
private bool DoFlush(RowPresenter rowPresenter, T element)
{
bool result = false;
for (int i = 0; i < _flushFuncs.Count; i++)
{
var flush = _flushFuncs[i];
var flushed = flush(rowPresenter, element);
if (flushed)
{
result = true;
}
}
return(result);
}
private void VerifyInsert(RowPresenter child)
{
if (child == null)
{
VerifyNoPendingEdit();
}
else
{
if (child.Parent != this)
{
throw new ArgumentException(DiagnosticMessages.RowPresenter_InvalidChildRow, nameof(child));
}
child.VerifyNoPendingEdit();
}
}
internal void ExitEdit(RowPresenter rowAfterEditing)
{
Debug.Assert(!CurrentRow.IsEditing);
if (_progress != null && rowAfterEditing != null)
{
Validate(rowAfterEditing, false);
}
_snapshot = null;
_flushingErrors = null;
if (rowAfterEditing != null)
{
ClearAsyncErrors(rowAfterEditing);
}
Template.RowAsyncValidators.ForEach(x => x.Reset());
}
internal sealed override void PerformSetup(RowPresenter rowPresenter)
{
for (int i = 0; i < _childBindings.Count; i++)
{
var childBinding = _childBindings[i];
if (childBinding.GetSettingUpElement() != null)
{
childBinding.Setup(rowPresenter);
}
}
_onRefresh?.Invoke(SettingUpElement, rowPresenter);
var rowElement = SettingUpElement as IRowElement;
rowElement?.Setup(rowPresenter);
}
/// <summary>
/// Selects specified <see cref="RowPresenter"/>.
/// </summary>
/// <param name="rowPresenter">The specified <see cref="RowPresenter"/>.</param>
/// <param name="selectionMode">The selection mode.</param>
/// <param name="ensureVisible">Indicates whether selected row must be visible.</param>
/// <param name="beforeSelecting">A delegate will be invoked before selectinng.</param>
public void Select(RowPresenter rowPresenter, SelectionMode selectionMode, bool ensureVisible = true, Action beforeSelecting = null)
{
VerifyRowPresenter(rowPresenter, nameof(rowPresenter));
var oldCurrentRow = CurrentRow;
beforeSelecting?.Invoke();
SuspendInvalidateView();
CurrentRow = rowPresenter;
RequireLayoutManager().Select(rowPresenter, selectionMode, oldCurrentRow);
ResumeInvalidateView();
if (ensureVisible && Scrollable != null)
{
Scrollable.EnsureCurrentRowVisible();
}
}
internal bool IsDescendantOf(RowPresenter rowPresenter)
{
if (rowPresenter == null)
{
return(false);
}
for (var parent = Parent; parent != null; parent = parent.Parent)
{
if (parent == rowPresenter)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Determines whether validation error is visible.
/// </summary>
/// <param name="rowPresenter">The <see cref="RowPresenter"/>.</param>
/// <param name="columns">The columns.</param>
/// <returns><see langword="true"/> if validation error is visible, otherwise <see langword="false"/>.</returns>
public bool IsVisible(RowPresenter rowPresenter, IColumns columns)
{
rowPresenter.VerifyNotNull(nameof(rowPresenter));
if (columns == null || columns.Count == 0)
{
return(false);
}
if (_progress == null)
{
return(true);
}
return(Exists(_progress, rowPresenter, columns));
}
internal void Validate(RowPresenter rowPresenter, bool showAll)
{
Debug.Assert(rowPresenter != null);
if (showAll)
{
ShowAll(rowPresenter);
}
ClearErrors(rowPresenter);
var dataRow = rowPresenter.DataRow;
var errors = Validate(dataRow);
if (errors != null && errors.Count > 0)
{
ErrorsByRow.Add(rowPresenter, errors);
}
}
private bool AnyBlockingValidatingInput(RowPresenter rowPresenter, Input <RowBinding, IColumns> input, bool isPreceding)
{
for (int i = 0; i < Inputs.Count; i++)
{
if (input.Index == i)
{
continue;
}
var canBlock = isPreceding ? Inputs[i].IsPrecedingOf(input) : input.IsPrecedingOf(Inputs[i]);
if (canBlock && IsValidatingStatus(rowPresenter, Inputs[i], null))
{
return(true);
}
}
return(false);
}
internal void OnRowDisposed(RowPresenter rowPresenter)
{
if (_progress != null)
{
if (_progress.ContainsKey(rowPresenter))
{
_progress.Remove(rowPresenter);
}
if (_valueChanged.ContainsKey(rowPresenter))
{
_valueChanged.Remove(rowPresenter);
}
}
ClearErrors(rowPresenter);
ClearAsyncErrors(rowPresenter);
}
