diff options
Diffstat (limited to 'Xamarin.Forms.Platform.iOS/ContextActionCell.cs')
| -rw-r--r-- | Xamarin.Forms.Platform.iOS/ContextActionCell.cs | 715 |
1 files changed, 715 insertions, 0 deletions
diff --git a/Xamarin.Forms.Platform.iOS/ContextActionCell.cs b/Xamarin.Forms.Platform.iOS/ContextActionCell.cs new file mode 100644 index 00000000..a2409c62 --- /dev/null +++ b/Xamarin.Forms.Platform.iOS/ContextActionCell.cs @@ -0,0 +1,715 @@ +using System; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Collections.Generic; +using System.Drawing; +using Xamarin.Forms.Platform.iOS.Resources; +#if __UNIFIED__ +using UIKit; +using Foundation; +#else +using MonoTouch.UIKit; +using MonoTouch.Foundation; +#endif +#if __UNIFIED__ +using RectangleF = CoreGraphics.CGRect; +using SizeF = CoreGraphics.CGSize; +using PointF = CoreGraphics.CGPoint; + +#else +using nfloat=System.Single; +using nint=System.Int32; +#endif + +namespace Xamarin.Forms.Platform.iOS +{ + internal class ContextActionsCell : UITableViewCell, INativeElementView + { + public const string Key = "ContextActionsCell"; + + static readonly UIImage DestructiveBackground; + static readonly UIImage NormalBackground; + readonly List<UIButton> _buttons = new List<UIButton>(); + readonly List<MenuItem> _menuItems = new List<MenuItem>(); + + Cell _cell; + UIButton _moreButton; + UIScrollView _scroller; + UITableView _tableView; + + static ContextActionsCell() + { + var rect = new RectangleF(0, 0, 1, 1); + var size = rect.Size; + + UIGraphics.BeginImageContext(size); + var context = UIGraphics.GetCurrentContext(); + context.SetFillColor(1, 0, 0, 1); + context.FillRect(rect); + DestructiveBackground = UIGraphics.GetImageFromCurrentImageContext(); + + context.SetFillColor(UIColor.LightGray.ToColor().ToCGColor()); + context.FillRect(rect); + + NormalBackground = UIGraphics.GetImageFromCurrentImageContext(); + + context.Dispose(); + } + + public ContextActionsCell() : base(UITableViewCellStyle.Default, Key) + { + } + + public ContextActionsCell(string templateId) : base(UITableViewCellStyle.Default, Key + templateId) + { + } + + public UITableViewCell ContentCell { get; private set; } + + public bool IsOpen + { + get { return ScrollDelegate.IsOpen; } + } + + ContextScrollViewDelegate ScrollDelegate + { + get { return (ContextScrollViewDelegate)_scroller.Delegate; } + } + + Element INativeElementView.Element + { + get + { + var boxedCell = ContentCell as INativeElementView; + if (boxedCell == null) + { + throw new InvalidOperationException($"Implement {nameof(INativeElementView)} on cell renderer: {ContentCell.GetType().AssemblyQualifiedName}"); + } + + return boxedCell.Element; + } + } + + public void Close() + { + _scroller.ContentOffset = new PointF(0, 0); + } + + public override void LayoutSubviews() + { + base.LayoutSubviews(); + + if (_scroller == null || (_scroller != null && _scroller.Frame == Bounds)) + return; + + Update(_tableView, _cell, ContentCell); + + _scroller.Frame = Bounds; + ContentCell.Frame = Bounds; + + if (ContentCell is ViewCellRenderer.ViewTableCell && ContentCell.Subviews.Length > 0 && Math.Abs(ContentCell.Subviews[0].Frame.Height - Bounds.Height) > 1) + { + // Something goes weird inside iOS where LayoutSubviews wont get called when updating the bounds if the user + // forces us to flip flop between a ContextActionCell and a normal cell in the middle of actually displaying the cell + // so here we are going to hack it a forced update. Leave room for 1px of play because the border is 1 or .5px and must + // be accounted for. + // + // Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=39450 + ContentCell.LayoutSubviews(); + } + } + + public void PrepareForDeselect() + { + ScrollDelegate.PrepareForDeselect(_scroller); + } + + public override SizeF SizeThatFits(SizeF size) + { + return ContentCell.SizeThatFits(size); + } + + public void Update(UITableView tableView, Cell cell, UITableViewCell nativeCell) + { + var parentListView = cell.RealParent as ListView; + var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement; + if (_cell != cell && recycling) + { + if (_cell != null) + ((INotifyCollectionChanged)_cell.ContextActions).CollectionChanged -= OnContextItemsChanged; + + ((INotifyCollectionChanged)cell.ContextActions).CollectionChanged += OnContextItemsChanged; + } + + var height = Frame.Height; + var width = tableView.Frame.Width; + + nativeCell.Frame = new RectangleF(0, 0, width, height); + nativeCell.SetNeedsLayout(); + + var handler = new PropertyChangedEventHandler(OnMenuItemPropertyChanged); + + _tableView = tableView; + SetupSelection(tableView); + + if (_cell != null) + { + if (!recycling) + _cell.PropertyChanged -= OnCellPropertyChanged; + if (_menuItems.Count > 0) + { + if (!recycling) + ((INotifyCollectionChanged)_cell.ContextActions).CollectionChanged -= OnContextItemsChanged; + + foreach (var item in _menuItems) + item.PropertyChanged -= handler; + } + + _menuItems.Clear(); + } + + _menuItems.AddRange(cell.ContextActions); + + _cell = cell; + if (!recycling) + { + cell.PropertyChanged += OnCellPropertyChanged; + ((INotifyCollectionChanged)_cell.ContextActions).CollectionChanged += OnContextItemsChanged; + } + + var isOpen = false; + + if (_scroller == null) + { + _scroller = new UIScrollView(new RectangleF(0, 0, width, height)); + _scroller.ScrollsToTop = false; + _scroller.ShowsHorizontalScrollIndicator = false; + + if (Forms.IsiOS8OrNewer) + _scroller.PreservesSuperviewLayoutMargins = true; + + ContentView.AddSubview(_scroller); + } + else + { + _scroller.Frame = new RectangleF(0, 0, width, height); + isOpen = ScrollDelegate.IsOpen; + + for (var i = 0; i < _buttons.Count; i++) + { + var b = _buttons[i]; + b.RemoveFromSuperview(); + b.Dispose(); + } + + _buttons.Clear(); + + ScrollDelegate.Unhook(_scroller); + ScrollDelegate.Dispose(); + } + + if (ContentCell != nativeCell) + { + if (ContentCell != null) + { + ContentCell.RemoveFromSuperview(); + ContentCell = null; + } + + ContentCell = nativeCell; + + //Hack: if we have a ImageCell the insets are slightly different, + //the inset numbers user below were taken using the Reveal app from the default cells + if ((ContentCell as CellTableViewCell)?.Cell is ImageCell) + { + nfloat imageCellInsetLeft = 57; + nfloat imageCellInsetRight = 0; + if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad) + { + imageCellInsetLeft = 89; + imageCellInsetRight = imageCellInsetLeft / 2; + } + SeparatorInset = new UIEdgeInsets(0, imageCellInsetLeft, 0, imageCellInsetRight); + } + + _scroller.AddSubview(nativeCell); + } + + SetupButtons(width, height); + + UIView container = null; + + var totalWidth = width; + for (var i = _buttons.Count - 1; i >= 0; i--) + { + var b = _buttons[i]; + totalWidth += b.Frame.Width; + + if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0)) + _scroller.AddSubview(b); + else + { + if (container == null) + { + container = new iOS7ButtonContainer(b.Frame.Width); + _scroller.InsertSubview(container, 0); + } + + container.AddSubview(b); + } + } + + _scroller.Delegate = new ContextScrollViewDelegate(container, _buttons, isOpen); + _scroller.ContentSize = new SizeF(totalWidth, height); + + if (isOpen) + _scroller.SetContentOffset(new PointF(ScrollDelegate.ButtonsWidth, 0), false); + else + _scroller.SetContentOffset(new PointF(0, 0), false); + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (_scroller != null) + { + _scroller.Dispose(); + _scroller = null; + } + + _tableView = null; + + if (_moreButton != null) + { + _moreButton.Dispose(); + _moreButton = null; + } + + for (var i = 0; i < _buttons.Count; i++) + _buttons[i].Dispose(); + + _buttons.Clear(); + _menuItems.Clear(); + + if (_cell != null) + { + if (_cell.HasContextActions) + ((INotifyCollectionChanged)_cell.ContextActions).CollectionChanged -= OnContextItemsChanged; + _cell = null; + } + } + + base.Dispose(disposing); + } + + void ActivateMore() + { + var displayed = new HashSet<nint>(); + for (var i = 0; i < _buttons.Count; i++) + { + var tag = _buttons[i].Tag; + if (tag >= 0) + displayed.Add(tag); + } + + var frame = _moreButton.Frame; + if (!Forms.IsiOS8OrNewer) + { + var container = _moreButton.Superview; + frame = new RectangleF(container.Frame.X, 0, frame.Width, frame.Height); + } + + var x = frame.X - _scroller.ContentOffset.X; + + var path = _tableView.IndexPathForCell(this); + var rowPosition = _tableView.RectForRowAtIndexPath(path); + var sourceRect = new RectangleF(x, rowPosition.Y, rowPosition.Width, rowPosition.Height); + + if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0)) + { + var actionSheet = new MoreActionSheetController(); + + for (var i = 0; i < _cell.ContextActions.Count; i++) + { + if (displayed.Contains(i)) + continue; + + var item = _cell.ContextActions[i]; + var weakItem = new WeakReference<MenuItem>(item); + var action = UIAlertAction.Create(item.Text, UIAlertActionStyle.Default, a => + { + _scroller.SetContentOffset(new PointF(0, 0), true); + MenuItem mi; + if (weakItem.TryGetTarget(out mi)) + mi.Activate(); + }); + actionSheet.AddAction(action); + } + + var controller = GetController(); + if (controller == null) + throw new InvalidOperationException("No UIViewController found to present."); + + if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone) + { + var cancel = UIAlertAction.Create(StringResources.Cancel, UIAlertActionStyle.Cancel, null); + actionSheet.AddAction(cancel); + } + else + { + actionSheet.PopoverPresentationController.SourceView = _tableView; + actionSheet.PopoverPresentationController.SourceRect = sourceRect; + } + + controller.PresentViewController(actionSheet, true, null); + } + else + { + var d = new MoreActionSheetDelegate { Scroller = _scroller, Items = new List<MenuItem>() }; + + var actionSheet = new UIActionSheet(null, d); + + for (var i = 0; i < _cell.ContextActions.Count; i++) + { + if (displayed.Contains(i)) + continue; + + var item = _cell.ContextActions[i]; + d.Items.Add(item); + actionSheet.AddButton(item.Text); + } + + if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone) + { + var index = actionSheet.AddButton(StringResources.Cancel); + actionSheet.CancelButtonIndex = index; + } + + actionSheet.ShowFrom(sourceRect, _tableView, true); + } + } + + void CullButtons(nfloat acceptableTotalWidth, ref bool needMoreButton, ref nfloat largestButtonWidth) + { + while (largestButtonWidth * (_buttons.Count + (needMoreButton ? 1 : 0)) > acceptableTotalWidth && _buttons.Count > 1) + { + needMoreButton = true; + + var button = _buttons[_buttons.Count - 1]; + _buttons.RemoveAt(_buttons.Count - 1); + + if (largestButtonWidth == button.Frame.Width) + largestButtonWidth = GetLargestWidth(); + } + + if (needMoreButton && _cell.ContextActions.Count - _buttons.Count == 1) + _buttons.RemoveAt(_buttons.Count - 1); + } + + UIButton GetButton(MenuItem item) + { + var button = new UIButton(new RectangleF(0, 0, 1, 1)); + + if (!item.IsDestructive) + button.SetBackgroundImage(NormalBackground, UIControlState.Normal); + else + button.SetBackgroundImage(DestructiveBackground, UIControlState.Normal); + + button.SetTitle(item.Text, UIControlState.Normal); + button.TitleEdgeInsets = new UIEdgeInsets(0, 15, 0, 15); + + button.Enabled = item.IsEnabled; + + return button; + } + + UIViewController GetController() + { + Element e = _cell; + while (e.RealParent != null) + { + var renderer = Platform.GetRenderer((VisualElement)e.RealParent); + if (renderer.ViewController != null) + return renderer.ViewController; + + e = e.RealParent; + } + + return null; + } + + nfloat GetLargestWidth() + { + nfloat largestWidth = 0; + for (var i = 0; i < _buttons.Count; i++) + { + var frame = _buttons[i].Frame; + if (frame.Width > largestWidth) + largestWidth = frame.Width; + } + + return largestWidth; + } + + void OnButtonActivated(object sender, EventArgs e) + { + var button = (UIButton)sender; + if (button.Tag == -1) + ActivateMore(); + else + { + _scroller.SetContentOffset(new PointF(0, 0), true); + _cell.ContextActions[(int)button.Tag].Activate(); + } + } + + void OnCellPropertyChanged(object sender, PropertyChangedEventArgs e) + { + if (e.PropertyName == "HasContextActions") + { + var parentListView = _cell.RealParent as ListView; + var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement; + if (!recycling) + ReloadRow(); + } + } + + void OnContextItemsChanged(object sender, NotifyCollectionChangedEventArgs e) + { + var parentListView = _cell.RealParent as ListView; + var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement; + if (recycling) + Update(_tableView, _cell, ContentCell); + else + ReloadRow(); + // TODO: Perhaps make this nicer if it's open while adding + } + + void OnMenuItemPropertyChanged(object sender, PropertyChangedEventArgs e) + { + var parentListView = _cell.RealParent as ListView; + var recycling = parentListView != null && parentListView.CachingStrategy == ListViewCachingStrategy.RecycleElement; + if (recycling) + Update(_tableView, _cell, ContentCell); + else + ReloadRow(); + } + + void ReloadRow() + { + if (_scroller.ContentOffset.X > 0) + { + ((ContextScrollViewDelegate)_scroller.Delegate).ClosedCallback = () => + { + ReloadRowCore(); + ((ContextScrollViewDelegate)_scroller.Delegate).ClosedCallback = null; + }; + + _scroller.SetContentOffset(new PointF(0, 0), true); + } + else + ReloadRowCore(); + } + + void ReloadRowCore() + { + if (_cell.RealParent == null) + return; + + var path = _cell.GetIndexPath(); + + var selected = path.Equals(_tableView.IndexPathForSelectedRow); + + _tableView.ReloadRows(new[] { path }, UITableViewRowAnimation.None); + + if (selected) + { + _tableView.SelectRow(path, false, UITableViewScrollPosition.None); + _tableView.Source.RowSelected(_tableView, path); + } + } + + UIView SetupButtons(nfloat width, nfloat height) + { + MenuItem destructive = null; + nfloat largestWidth = 0, acceptableSize = width * 0.80f; + + for (var i = 0; i < _cell.ContextActions.Count; i++) + { + var item = _cell.ContextActions[i]; + + if (_buttons.Count == 3) + { + if (destructive != null) + break; + if (!item.IsDestructive) + continue; + + _buttons.RemoveAt(_buttons.Count - 1); + } + + if (item.IsDestructive) + destructive = item; + + var button = GetButton(item); + button.Tag = i; + var buttonWidth = button.TitleLabel.SizeThatFits(new SizeF(width, height)).Width + 30; + if (buttonWidth > largestWidth) + largestWidth = buttonWidth; + + if (destructive == item) + _buttons.Insert(0, button); + else + _buttons.Add(button); + } + + var needMore = _cell.ContextActions.Count > _buttons.Count; + + if (_cell.ContextActions.Count > 2) + CullButtons(acceptableSize, ref needMore, ref largestWidth); + + var resize = false; + if (needMore) + { + if (largestWidth * 2 > acceptableSize) + { + largestWidth = acceptableSize / 2; + resize = true; + } + + var button = new UIButton(new RectangleF(0, 0, largestWidth, height)); + button.SetBackgroundImage(NormalBackground, UIControlState.Normal); + button.TitleEdgeInsets = new UIEdgeInsets(0, 15, 0, 15); + button.SetTitle(StringResources.More, UIControlState.Normal); + + var moreWidth = button.TitleLabel.SizeThatFits(new SizeF(width, height)).Width + 30; + if (moreWidth > largestWidth) + { + largestWidth = moreWidth; + CullButtons(acceptableSize, ref needMore, ref largestWidth); + + if (largestWidth * 2 > acceptableSize) + { + largestWidth = acceptableSize / 2; + resize = true; + } + } + + button.Tag = -1; + button.TouchUpInside += OnButtonActivated; + if (resize) + button.TitleLabel.AdjustsFontSizeToFitWidth = true; + + _moreButton = button; + _buttons.Add(button); + } + + var handler = new PropertyChangedEventHandler(OnMenuItemPropertyChanged); + var totalWidth = _buttons.Count * largestWidth; + for (var n = 0; n < _buttons.Count; n++) + { + var b = _buttons[n]; + + if (b.Tag >= 0) + { + var item = _cell.ContextActions[(int)b.Tag]; + item.PropertyChanged += handler; + } + + var offset = (n + 1) * largestWidth; + + var x = width - offset; + if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0)) + x += totalWidth; + + b.Frame = new RectangleF(x, 0, largestWidth, height); + if (resize) + b.TitleLabel.AdjustsFontSizeToFitWidth = true; + + b.SetNeedsLayout(); + + if (b != _moreButton) + b.TouchUpInside += OnButtonActivated; + } + + return null; + } + + void SetupSelection(UITableView table) + { + for (var i = 0; i < table.GestureRecognizers.Length; i++) + { + var r = table.GestureRecognizers[i] as SelectGestureRecognizer; + if (r != null) + return; + } + + _tableView.AddGestureRecognizer(new SelectGestureRecognizer()); + } + + class SelectGestureRecognizer : UITapGestureRecognizer + { + NSIndexPath _lastPath; + + public SelectGestureRecognizer() : base(Tapped) + { + ShouldReceiveTouch = (recognizer, touch) => + { + var table = (UITableView)View; + var pos = touch.LocationInView(table); + + _lastPath = table.IndexPathForRowAtPoint(pos); + if (_lastPath == null) + return false; + + var cell = table.CellAt(_lastPath) as ContextActionsCell; + + return cell != null; + }; + } + + static void Tapped(UIGestureRecognizer recognizer) + { + var selector = (SelectGestureRecognizer)recognizer; + + var table = (UITableView)recognizer.View; + + if (!selector._lastPath.Equals(table.IndexPathForSelectedRow)) + table.SelectRow(selector._lastPath, false, UITableViewScrollPosition.None); + table.Source.RowSelected(table, selector._lastPath); + } + } + + class MoreActionSheetController : UIAlertController + { + public override UIAlertControllerStyle PreferredStyle + { + get { return UIAlertControllerStyle.ActionSheet; } + } + + public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration) + { + DismissViewController(false, null); + } + } + + class MoreActionSheetDelegate : UIActionSheetDelegate + { + public List<MenuItem> Items; + public UIScrollView Scroller; + + public override void Clicked(UIActionSheet actionSheet, nint buttonIndex) + { + if (buttonIndex == Items.Count) + return; // Cancel button + + Scroller.SetContentOffset(new PointF(0, 0), true); + + // do not activate a -1 index when dismissing by clicking outside the popover + if (buttonIndex >= 0) + Items[(int)buttonIndex].Activate(); + } + } + } +}
\ No newline at end of file |