internal void Setup(RowPresenter rowPresenter)
{
Debug.Assert(RowPresenter == null && rowPresenter != null);
RowPresenter = rowPresenter;
rowPresenter.View = this;
if (ElementCollection == null)
{
ElementCollection = ElementCollectionFactory.Create(null);
}
SetupElements(true);
var behaviors = Behaviors;
for (int i = 0; i < behaviors.Count; i++)
{
behaviors[i].Setup(this);
behaviors[i].Refresh(this);
}
var commandService = rowPresenter.DataPresenter?.GetService <ICommandService>(); // rowPresenter.DataPresenter could be null in unit tests.
if (commandService != null)
{
this.SetupCommandEntries(commandService, GetCommandEntries);
}
SettingUp(this, EventArgs.Empty);
HasSetup = true;
}
protected override void OnCurrentRowChanged(RowPresenter oldValue)
{
if (ElementCollection != null && _focusTo == null)
{
CoerceCurrentContainerView(oldValue);
}
}
protected InsertChildHandler(RowPresenter parentRow, RowPresenter reference)
: base(parentRow.RowManager, reference)
{
Debug.Assert(parentRow != null && !parentRow.IsVirtual);
Debug.Assert(reference == null || reference.Parent == parentRow);
ParentRow = parentRow;
}
protected sealed override void OpenEdit(RowManager rowManager)
{
Debug.Assert(rowManager == RowManager);
KeepInitialInputElement(rowManager);
if (rowManager.VirtualRow != null)
{
_insertingRow = rowManager.VirtualRow;
_insertingRow.DataRow = DataSet.BeginAdd();
}
else
{
_insertingRow = new RowPresenter(rowManager, DataSet.BeginAdd());
}
_insertingRow.RawIndex = InsertingRowRawIndex;
if (rowManager.VirtualRowPlacement == VirtualRowPlacement.Head)
{
rowManager.VirtualRow = new RowPresenter(rowManager, 0);
}
else if (rowManager.VirtualRowPlacement == VirtualRowPlacement.Tail)
{
rowManager.VirtualRow = new RowPresenter(rowManager, -1);
}
else if (rowManager.VirtualRow != null)
{
rowManager.VirtualRow = null;
}
rowManager.Editing = this;
rowManager.OnRowsChanged();
rowManager.SetCurrentRow(_insertingRow, false);
}
protected InsertHandler(RowManager rowManager, RowPresenter reference)
{
Debug.Assert(rowManager != null);
Debug.Assert(reference == null || reference.RowManager == rowManager);
RowManager = rowManager;
Reference = reference;
}
protected override void OnRowAdded(RowPresenter row, int index)
{
if (_onRowAdded != null)
{
_onRowAdded(row, index);
}
}
public void RowMapper_OnRowAdded_recursive()
{
var dataSet = DataSetMock.ProductCategories(3);
RowPresenter addedRow = null;
int addedRowIndex = -1;
var rowMapper = CreateRecursiveRowMapper(dataSet).SetupOnRowAdded((row, index) =>
{
addedRow = row;
addedRowIndex = index;
});
// add row to the leaf level, this should trigger data changed events wiring to the next level.
var newRow = dataSet.SubCategories(0).SubCategories(0).SubCategories(0).AddRow();
var rows = rowMapper.Rows;
Assert.AreEqual(1, rows[0].Children[0].Children[0].Children.Count);
Verify(rows[0].Children[0].Children[0].Children[0], newRow);
Assert.AreEqual(newRow, addedRow.DataRow);
Assert.AreEqual(0, addedRowIndex);
// add another row to the leaf level, to verify data changed events correctly wired.
var newRow2 = dataSet.SubCategories(0).SubCategories(0).SubCategories(0).SubCategories(0).AddRow();
Assert.AreEqual(1, rows[0].Children[0].Children[0].Children[0].Children.Count);
Verify(rows[0].Children[0].Children[0].Children[0].Children[0], newRow2);
Assert.AreEqual(newRow2, addedRow.DataRow);
Assert.AreEqual(0, addedRowIndex);
}
protected sealed override void OnCurrentRowChanged(RowPresenter oldValue)
{
base.OnCurrentRowChanged(oldValue);
_rowValidation?.OnCurrentRowChanged(oldValue);
DataPresenter?.OnCurrentRowChanged(oldValue);
InvalidateView();
}
internal IValidationErrors GetVisibleValidationErrors(RowPresenter rowPresenter)
{
Debug.Assert(rowPresenter != null);
if (_rowValidation == null)
{
return(ValidationErrors.Empty);
}
var result = ValidationErrors.Empty;
foreach (var input in _rowValidation.Inputs)
{
var errors = GetValidationInfo(rowPresenter, input).Errors;
for (int i = 0; i < errors.Count; i++)
{
result = result.Add(errors[i]);
}
}
{
var errors = GetValidationInfo(rowPresenter.View).Errors;
for (int i = 0; i < errors.Count; i++)
{
result = result.Add(errors[i]);
}
}
return(result.Seal());
}
private void Remove(RowPresenter row)
{
Debug.Assert(row != null);
if (_mappings != null)
{
_mappings.Remove(row.DataRow);
}
var parent = row.Parent;
var index = IndexOf(row);
RemoveAt(parent, index);
DisposeRow(row);
if (parent != null && parent.Children.Count == 0 && !PassesFilter(parent.DataRow))
{
Remove(parent);
}
else
{
OnRowRemoved(parent, index);
}
row.Dispose();
}
void IRowElement.Cleanup(RowPresenter rowPresenter)
{
var proxyRowInput = GetProxyRowInput();
Cleanup(proxyRowInput);
CleanupCommands();
}
internal sealed override UIElement Setup(RowPresenter rowPresenter)
{
Debug.Assert(SettingUpElement != null);
SettingUpElement.SetRowPresenter(this, rowPresenter);
PerformSetup(rowPresenter);
return(SettingUpElement);
}
private void CoerceCurrentContainerView(RowPresenter oldValue)
{
var newValue = CurrentRow;
if (newValue != null)
{
if (CurrentContainerView == null)
{
Debug.Assert(ContainerViewList.Count == 0);
ResetCurrentContainerView(Setup(newValue));
ElementCollection.Insert(HeadScalarElementsCount, CurrentContainerView);
}
else if (oldValue != newValue)
{
if (ContainerViewList.Count == 0 || oldValue.IsDisposed)
{
CurrentContainerView.ReloadCurrentRow(oldValue);
}
else
{
CoerceCurrentRowView(oldValue.View);
}
}
}
else if (CurrentContainerView != null)
{
ClearCurrentContainerView();
}
}
protected override void OnRowUpdated(RowPresenter row, ValueChangedEventArgs e)
{
if (_onRowUpdated != null)
{
_onRowUpdated(row, e);
}
}
protected override void OnRowMoved(RowPresenter row, int oldIndex, int newIndex)
{
if (_onRowMoved != null)
{
_onRowMoved(row, oldIndex, newIndex);
}
}
protected override void OnRowRemoved(RowPresenter parent, int index)
{
if (_onRowRemoved != null)
{
_onRowRemoved(parent, index);
}
}
public void OnItemSelected(Presenter.ViewHolder itemViewHolder, Java.Lang.Object item,
RowPresenter.ViewHolder rowViewHolder, Row row)
{
if (item is Movie) {
mBackgroundURI = ((Movie)item).GetBackgroundImageURI ();
StartBackgroundTimer ();
}
}
internal static void SetRowPresenter(this DataRow dataRow, RowPresenter value)
{
s_dataRowToRowPresenterMappings.Remove(dataRow);
if (value != null)
{
s_dataRowToRowPresenterMappings.Add(dataRow, value);
}
}
void IRowElement.Cleanup(RowPresenter rowPresenter)
{
Command = null;
ForeignKey = null;
Lookup = null;
ValueBag.Clear();
this.CleanupCommandEntries();
}
internal void Cleanup(RowPresenter row)
{
var rowView = row.View;
Debug.Assert(rowView != null);
rowView.Cleanup();
rowView.SetBlockView(null);
}
private static UIElement GenerateElement(RowBinding binding, RowPresenter p)
{
binding.BeginSetup(null);
var result = binding.Setup(p);
binding.EndSetup();
binding.Refresh(result);
return(result);
}
public void OnItemClicked(Presenter.ViewHolder itemViewHolder, Java.Lang.Object item,
RowPresenter.ViewHolder rowViewHolder, Row row)
{
if (item is Movie) {
var movie = (Movie)item;
var intent = new Intent (this.Activity, typeof(DetailsActivity));
intent.PutExtra (GetString (Resource.String.movie), Utils.Serialize(movie));
StartActivity (intent);
}
}
private bool CreateIfNotExist(DataRow dataRow, out RowPresenter row)
{
if (_mappings.TryGetValue(dataRow, out row))
{
return(true);
}
row = CreateRowPresenter(dataRow);
_mappings.Add(dataRow, row);
return(false);
}
private bool AnyLookupProjection(RowPresenter row)
{
var node = row.GetValue(_.Node);
if (node.Kind == ModelMapper.NodeKind.Projection && node.Name == LOOKUP_PROJECTION)
{
return(true);
}
return(row.IsExpanded ? false : row.Children.Any(AnyLookupProjection));
}
private void InsertAt(int index, RowPresenter row)
{
if (row.Parent == null)
{
_rows.Insert(index, row);
}
else
{
row.Parent.InsertChild(index, row);
}
}
private int GetIndex(RowPresenter row, int oldIndex)
{
if (!IsQuery)
{
return(row.DataRow.Index);
}
var list = oldIndex < 0 ? GetContainerList(row) : new OneItemExcludedList <RowPresenter>(GetContainerList(row), oldIndex);
return(BinarySearch(list, row));
}
private static string GetDisplayText(DirectoryTreeItem _, RowPresenter p)
{
var result = p.GetValue(_.Path);
var depth = p.Depth;
if (depth > 0)
{
result = Path.GetFileName(result);
}
return(result);
}
public void Refresh(TextBlock v, RowPresenter p)
{
if (_scalar.Value == IGNORE)
{
v.Foreground = Brushes.LightGray;
}
else
{
v.ClearValue(ForegroundProperty);
}
}
protected virtual Size GetAvailableAutoSize(RowBinding rowBinding, RowPresenter rowPresenter, out IReadOnlyList <GridColumn> autoWidthColumns, out double measuredWidth,
out IReadOnlyList <GridRow> autoHeightGridRows, out double measuredHeight)
{
autoWidthColumns = rowBinding.AutoWidthGridColumns;
autoHeightGridRows = rowBinding.AutoHeightGridRows;
var gridRange = rowBinding.GridRange;
measuredWidth = gridRange.GetMeasuredWidth(x => !x.IsAutoLength);
measuredHeight = gridRange.GetMeasuredHeight(x => !x.IsAutoLength);
return(rowBinding.AvailableAutoSize);
}
private void RemoveAt(RowPresenter parent, int index)
{
if (parent != null)
{
parent.RemoveChild(index);
}
else
{
_rows.RemoveAt(index);
}
}
internal RowView Setup(BlockView blockView, RowPresenter row)
{
Debug.Assert(blockView != null);
Debug.Assert(row != null && row.View == null);
var rowView = Create(Template.CreateRowView);
rowView.SetBlockView(blockView);
rowView.Setup(row);
return(rowView);
}
private void MoveTo(RowPresenter rowPresenter, bool ensureSelectVisible = true)
{
if (ShouldSelectByKey)
{
Select(rowPresenter, SelectionMode.Single, ensureSelectVisible);
}
else
{
CurrentRow = rowPresenter;
Scrollable.EnsureCurrentRowVisible();
}
}
public void OnItemSelected(Presenter.ViewHolder itemViewHolder, Java.Lang.Object item,
RowPresenter.ViewHolder rowViewHolder, Row row)
{
//Do nothing
}
protected override void OnBindRowViewHolder(RowPresenter.ViewHolder vh, Object item)
{
base.OnBindRowViewHolder(vh, item);
}
protected override void OnUnbindRowViewHolder(RowPresenter.ViewHolder vh)
{
base.OnUnbindRowViewHolder(vh);
}
