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); }