public static void Reload(this Element element, UITableViewRowAnimation animation = UITableViewRowAnimation.None) { if (element.GetContainerTableView() == null) return; var root = element.GetImmediateRootElement(); if (root != null) root.Reload(element, animation); }
public static void Reload(this Element element, UITableViewRowAnimation animation = UITableViewRowAnimation.None) { if (element.GetContainerTableView() == null) { return; } var root = element.GetImmediateRootElement(); if (root != null) { root.Reload(element, animation); } }
public void Reset(IEnumerable <Element> elements, UITableViewRowAnimation animation = UITableViewRowAnimation.Fade) { _elements.Clear(); _elements.AddRange(elements); foreach (var e in _elements) { e.Section = this; } if (Root != null && Root.TableView != null) { Root.TableView.ReloadData(); } }
private void RemoveRow(Section section, object item, UITableViewRowAnimation animation = UITableViewRowAnimation.Fade) { RemovePropertyChangedHandler(item); var row = section.DataContext.IndexOf(item); section.DataContext.Remove(item); if (Controller == MonoMobileApplication.CurrentViewController) { var indexPaths = new NSIndexPath[] { NSIndexPath.FromRowSection(row, section.Index) }; Controller.TableView.DeleteRows(indexPaths, animation); } }
public void Remove(Section s, UITableViewRowAnimation anim) { if (s == null) { return; } int idx = Sections.IndexOf(s); if (idx == -1) { return; } RemoveAt(idx, anim); }
private void ReplaceRow(Section section, object oldItem, object newItem, UITableViewRowAnimation animation = UITableViewRowAnimation.Fade) { RemovePropertyChangedHandler(oldItem); AddPropertyChangedHandler(newItem); var row = section.DataContext.IndexOf(oldItem); section.DataContext[row] = newItem; if (Controller == MonoMobileApplication.CurrentViewController) { var indexPaths = new NSIndexPath[] { NSIndexPath.FromRowSection(row, section.Index) }; Controller.TableView.ReloadRows(indexPaths, animation); } }
/// <summary> /// Removes a section at a specified location using the specified animation /// </summary> /// <param name="idx"> /// A <see cref="System.Int32"/> /// </param> /// <param name="anim"> /// A <see cref="UITableViewRowAnimation"/> /// </param> public void RemoveAt(int idx, UITableViewRowAnimation anim) { if (idx < 0 || idx >= Sections.Count) { return; } Sections.RemoveAt(idx); if (TableView == null) { return; } TableView.DeleteSections(NSIndexSet.FromIndex(idx), anim); }
void InsertVisual(int idx, UITableViewRowAnimation anim, int count) { if (Root == null || Root.TableView == null) { return; } int sidx = Root.IndexOf(this); var paths = new NSIndexPath [count]; for (int i = 0; i < count; i++) { paths [i] = NSIndexPath.FromRowSection(idx + i, sidx); } Root.TableView.InsertRows(paths, anim); }
public override void DeleteRows(NSIndexPath[] atIndexPaths, UITableViewRowAnimation withRowAnimation) { base.DeleteRows(atIndexPaths, withRowAnimation); if (Comparables.Count == 0) { InsertRows(atIndexPaths, withRowAnimation); SetScrollAndSelection(); } OnComparableDeleted.Fire(this, EventArgs.Empty); if (atIndexPaths[0].Row == 0) { UpdateCheapestComparable(Comparables.Count == 0 ? null : Comparables[0]); } }
public void Remove(Element e, UITableViewRowAnimation animation = UITableViewRowAnimation.Fade) { if (e == null) { return; } for (int i = _elements.Count; i > 0;) { i--; if (_elements [i] == e) { RemoveRange(i, 1, animation); e.Section = null; return; } } }
private void InsertVisual(int idx, UITableViewRowAnimation anim, int count) { var root = Parent as RootElement; if (root?.TableView == null) { return; } int sidx = root.IndexOf(this); var paths = new NSIndexPath[count]; for (int i = 0; i < count; i++) { paths[i] = NSIndexPath.FromRowSection(idx + i, sidx); } root.TableView.InsertRows(paths, anim); }
/// <summary> /// Remove a range of elements from the section with the given animation /// </summary> /// <param name="start"> /// Starting position /// </param> /// <param name="count"> /// Number of elements to remove form the section /// </param> /// <param name="anim"> /// The animation to use while removing the elements /// </param> public void RemoveRange(int start, int count, UITableViewRowAnimation anim) { if (start < 0 || start >= Elements.Count) { return; } if (count == 0) { return; } if (start + count > Elements.Count) { count = Elements.Count - start; } Elements.RemoveRange(start, count); if (Root == null || Root.TableView == null) { return; } int sidx = Root.IndexOf(this as ISection); var paths = new NSIndexPath[count]; for (int i = 0; i < count; i++) { paths[i] = NSIndexPath.FromRowSection(start + i, sidx); } Root.TableView.DeleteRows(paths, anim); foreach (var element in Elements) { if (element.Cell != null) { element.Cell.SetNeedsDisplay(); } } }
public void Reload(Section section, UITableViewRowAnimation animation) { if (section == null) { throw new ArgumentNullException("section"); } if (section.Parent == null || section.Parent != this) { throw new ArgumentException("Section is not attached to this root"); } int idx = 0; foreach (var sect in Sections) { if (sect == section) { TableView.ReloadSections(new NSIndexSet((uint)idx), animation); return; } idx++; } }
public void Insert(int idx, UITableViewRowAnimation anim, params Section [] newSections) { if (idx < 0 || idx > _sections.Count) { return; } if (newSections == null) { return; } _tableView.Get()?.BeginUpdates(); int pos = idx; foreach (var s in newSections) { s.Root = this; _sections.Insert(pos++, s); } _tableView.Get()?.InsertSections(MakeIndexSet(idx, newSections.Length), anim); _tableView.Get()?.EndUpdates(); }
protected virtual void ReloadSection( nint section, [NotNull] NotifyCollectionChangedEventArgs args, UITableViewRowAnimation withRowAnimation = UITableViewRowAnimation.Automatic) { if (args == null) { throw new ArgumentNullException(nameof(args)); } if (TableViewWeakReference.TryGetTarget(out var tableView)) { switch (args.Action) { case NotifyCollectionChangedAction.Add: tableView.SupportPerformBatchUpdates(() => tableView.InsertRows(args.ToNewIndexPaths(section), withRowAnimation)); break; case NotifyCollectionChangedAction.Move: tableView.MoveRow(args.ToOldIndexPath(section), args.ToNewIndexPath(section)); break; case NotifyCollectionChangedAction.Replace: tableView.SupportPerformBatchUpdates(() => tableView.ReloadRows(args.ToNewIndexPaths(section), withRowAnimation)); break; case NotifyCollectionChangedAction.Remove: tableView.SupportPerformBatchUpdates(() => tableView.DeleteRows(args.ToOldIndexPaths(section), withRowAnimation)); break; default: tableView.ReloadSections(NSIndexSet.FromIndex(section), withRowAnimation); break; } } }
/// <summary> /// Inserts a series of elements into the Section using the specified animation /// </summary> /// <param name="idx"> /// The index where the elements are inserted /// </param> /// <param name="anim"> /// The animation to use /// </param> /// <param name="newElements"> /// A series of elements. /// </param> public void Insert(int idx, UITableViewRowAnimation anim, params Element [] newElements) { if (newElements == null) { return; } var elements = newElements.Except(_elements); int pos = idx; int inserts = 0; foreach (var e in elements) { inserts++; _elements.Insert(pos++, e); e.SetSection(this); } if (inserts == 0) { return; } if (Root != null && Root.TableView != null) { if (anim == UITableViewRowAnimation.None) { Root.TableView.ReloadData(); } else { InsertVisual(idx, anim, inserts); } } }
/// <summary> /// Remove a range of elements from the section with the given animation /// </summary> /// <param name="start"> /// Starting position /// </param> /// <param name="count"> /// Number of elements to remove form the section /// </param> /// <param name="anim"> /// The animation to use while removing the elements /// </param> public void RemoveRange(int start, int count, UITableViewRowAnimation anim) { if (start < 0 || start >= Elements.Count) return; if (count == 0) return; var root = Parent as RootElement; if (start + count > Elements.Count) count = Elements.Count - start; Elements.RemoveRange(start, count); if (root == null || root.TableView == null) return; int sidx = root.IndexOf(this); var paths = new NSIndexPath[count]; for (int i = 0; i < count; i++) paths[i] = NSIndexPath.FromRowSection(start + i, sidx); root.TableView.DeleteRows(paths, anim); }
/// <summary> /// Inserts a single RootElement into the Section using the specified animation /// </summary> /// <param name="idx"> /// The index where the elements are inserted /// </param> /// <param name="anim"> /// The animation to use /// </param> /// <param name="newElements"> /// A series of elements. /// </param> public void Insert (int idx, UITableViewRowAnimation anim, RootElement newElement) { Insert (idx, anim, (Element) newElement); }
protected override void ReloadSection(nint section, NotifyCollectionChangedEventArgs args, UITableViewRowAnimation withRowAnimation = UITableViewRowAnimation.Automatic) { base.ReloadSection(section, args, withRowAnimation); if (TableViewWeakReference.TryGetTarget(out var tableView)) { var totalItemsCount = RowsInSection(tableView, DefaultSection); foreach (var cell in tableView.VisibleCells) { var indexPath = tableView.IndexPathForCell(cell); UpdateCellDevider(cell, indexPath, totalItemsCount); } } }
private void InsertVisual(int idx, UITableViewRowAnimation anim, int count) { var root = Parent as RootElement; if (root == null || root.TableView == null) return; int sidx = root.IndexOf(this); var paths = new NSIndexPath[count]; for (int i = 0; i < count; i++) paths[i] = NSIndexPath.FromRowSection(idx + i, sidx); root.TableView.InsertRows(paths, anim); }
/// <summary> /// Removes a section at a specified location using the specified animation /// </summary> /// <param name="idx"> /// A <see cref="System.Int32"/> /// </param> /// <param name="anim"> /// A <see cref="UITableViewRowAnimation"/> /// </param> public void RemoveAt(int idx, UITableViewRowAnimation anim) { if (idx < 0 || idx >= Sections.Count) return; Sections.RemoveAt (idx); if (TableView == null) return; TableView.DeleteSections (NSIndexSet.FromIndex (idx), anim); }
public virtual void ReloadRowsAtIndexPaths(AnyObject[] indexPaths, UITableViewRowAnimation withRowAnimation) { }
public void Reload(Element element, UITableViewRowAnimation animation) { if (element == null) throw new ArgumentNullException ("element"); var section = element.Parent as Section; if (section == null) throw new ArgumentException ("Element is not attached to this root"); var root = section.Parent as RootElement; if (root == null) throw new ArgumentException ("Element is not attached to this root"); var path = element.IndexPath; if (path == null) return; TableView.ReloadRows (new NSIndexPath [] { path }, animation); }
void InsertVisual(int idx, UITableViewRowAnimation anim, int count) { if (Root == null || Root.TableView == null) return; int sidx = Root.IndexOf(this as ISection); var paths = new NSIndexPath[count]; for (int i = 0; i < count; i++) paths[i] = NSIndexPath.FromRowSection(idx + i, sidx); Root.TableView.InsertRows(paths, anim); }
// // /// <summary> // /// Use to add a UIView to a section, it makes the section opaque, to // /// get a transparent one, you must manually call UIViewElement // public void Add(UIView view) // { // if (view == null) // return; // Add(new UIViewElement(null, view, false)); // } // // /// <summary> // /// Adds the UIViews to the section. // /// </summary>fparent // /// <param name="views"> // /// An enumarable list that can be produced by something like: // /// from x in ... select (UIView) new UIFoo (); // /// </param> // public void Add(IEnumerable<UIView> views) // { // foreach (var v in views) // Add(v); // } /// <summary> /// Inserts a series of elements into the Section using the specified animation /// </summary> /// <param name="idx"> /// The index where the elements are inserted /// </param> /// <param name="anim"> /// The animation to use /// </param> /// <param name="newElements"> /// A series of elements. /// </param> public void Insert(int idx, UITableViewRowAnimation anim, params IElement[] newElements) { if (newElements == null) return; int pos = idx; foreach (var e in newElements) { Elements.Insert(pos++, e); e.Parent = this; } if (Root != null && Root.TableView != null) { if (anim == UITableViewRowAnimation.None) Root.TableView.ReloadData(); else InsertVisual(idx, anim, newElements.Length); } }
public virtual void ReloadSections(NSIndexSet sections, UITableViewRowAnimation withRowAnimation) { }
public override void InsertRows(NSIndexPath[] atIndexPaths, UITableViewRowAnimation withRowAnimation) { base.InsertRows(atIndexPaths, withRowAnimation); }
protected abstract void ReloadSections( [NotNull] NotifyCollectionChangedEventArgs args, UITableViewRowAnimation withRowAnimation = UITableViewRowAnimation.Automatic);
private void InsertRow(Section section, int row, object item, UITableViewRowAnimation animation = UITableViewRowAnimation.Fade) { AddPropertyChangedHandler(item); section.DataContext.Insert(row, item); if (Controller == MonoMobileApplication.CurrentViewController) { var indexPaths = new NSIndexPath[] { NSIndexPath.FromRowSection(row, section.Index) }; InvokeOnMainThread(()=> Controller.TableView.InsertRows(indexPaths, animation)); } }
private void ReplaceRow(Section section, object oldItem, object newItem, UITableViewRowAnimation animation = UITableViewRowAnimation.Fade) { RemovePropertyChangedHandler(oldItem); AddPropertyChangedHandler(newItem); var row = section.DataContext.IndexOf(oldItem); section.DataContext[row] = newItem; if (Controller == MonoMobileApplication.CurrentViewController) { var indexPaths = new NSIndexPath[] { NSIndexPath.FromRowSection(row, section.Index) }; InvokeOnMainThread(()=> Controller.TableView.ReloadRows(indexPaths, animation)); } }
public void Remove(Section s, UITableViewRowAnimation anim) { if (s == null) return; int idx = Sections.IndexOf (s); if (idx == -1) return; RemoveAt (idx, anim); }
/// <summary> /// Inserts a new section into the RootElement /// </summary> /// <param name="idx"> /// The index where the section is added <see cref="System.Int32"/> /// </param> /// <param name="anim"> /// The <see cref="UITableViewRowAnimation"/> type. /// </param> /// <param name="newSections"> /// A <see cref="Section[]"/> list of sections to insert /// </param> /// <remarks> /// This inserts the specified list of sections (a params argument) into the /// root using the specified animation. /// </remarks> public void Insert(int idx, UITableViewRowAnimation anim, params Section [] newSections) { if (idx < 0 || idx > Sections.Count) return; if (newSections == null) return; if (TableView != null) TableView.BeginUpdates (); int pos = idx; foreach (var s in newSections){ s.Parent = this; Sections.Insert (pos++, s); } if (TableView == null) return; TableView.InsertSections (MakeIndexSet (idx, newSections.Length), anim); TableView.EndUpdates (); }
/// <summary> /// Inserts a series of elements into the Section using the specified animation /// </summary> /// <param name="idx"> /// The index where the elements are inserted /// </param> /// <param name="anim"> /// The animation to use /// </param> /// <param name="newElements"> /// A series of elements. /// </param> public void Insert (int idx, UITableViewRowAnimation anim, params Element [] newElements) { if (newElements == null) return; int pos = idx; foreach (var e in newElements){ Elements.Insert (pos++, e); e.Parent = this; } if (Parent != null) InsertVisual (idx, anim, newElements.Length); }
public int Insert(int idx, UITableViewRowAnimation anim, IEnumerable<IElement> newElements) { if (newElements == null) return 0; int pos = idx; int count = 0; foreach (var e in newElements) { Elements.Insert(pos++, e); e.Parent = this; count++; } if (Root != null && Root.TableView != null) { if (anim == UITableViewRowAnimation.None) Root.TableView.ReloadData(); else InsertVisual(idx, anim, pos - idx); } return count; }
public void Reload(Section section, UITableViewRowAnimation animation) { if (section == null) throw new ArgumentNullException ("section"); if (section.Parent == null || section.Parent != this) throw new ArgumentException ("Section is not attached to this root"); int idx = 0; foreach (var sect in Sections){ if (sect == section){ TableView.ReloadSections (new NSIndexSet ((uint) idx), animation); return; } idx++; } }
/// <summary> /// Remove a range of elements from the section with the given animation /// </summary> /// <param name="start"> /// Starting position /// </param> /// <param name="count"> /// Number of elements to remove form the section /// </param> /// <param name="anim"> /// The animation to use while removing the elements /// </param> public void RemoveRange(int start, int count, UITableViewRowAnimation anim) { if (start < 0 || start >= Elements.Count) return; if (count == 0) return; if (start + count > Elements.Count) count = Elements.Count - start; // Elements.RemoveRange(start, count); if (Root == null || Root.TableView == null) return; int sidx = Root.IndexOf(this as ISection); var paths = new NSIndexPath[count]; for (int i = 0; i < count; i++) paths[i] = NSIndexPath.FromRowSection(start + i, sidx); Root.TableView.DeleteRows(paths, anim); foreach(var element in Elements) { if (element.Cell != null) element.Cell.SetNeedsDisplay(); } }
private void RemoveRow(Section section, object item, UITableViewRowAnimation animation = UITableViewRowAnimation.Fade) { RemovePropertyChangedHandler(item); var row = section.DataContext.IndexOf(item); section.DataContext.Remove(item); if (Controller == MonoMobileApplication.CurrentViewController) { var indexPaths = new NSIndexPath[] { NSIndexPath.FromRowSection(row, section.Index) }; Controller.TableView.DeleteRows(indexPaths, animation); } }