public override void LayoutSubviews()
{
base.LayoutSubviews();
double height = Bounds.Height;
double width = Bounds.Width;
if (_headerRenderer != null)
{
var e = _headerRenderer.Element;
var request = e.Measure(width, double.PositiveInfinity, MeasureFlags.IncludeMargins);
// Time for another story with Jason. Gather round children because the following Math.Ceiling will look like it's completely useless.
// You will remove it and test and find everything is fiiiiiine, but it is not fine, no it is far from fine. See iOS, or at least iOS 8
// has an issue where-by if the TableHeaderView happens to NOT be an integer height, it will add padding to the space between the content
// of the UITableView and the TableHeaderView to the tune of the difference between Math.Ceiling (height) - height. Now this seems fine
// and when you test it will be, EXCEPT that it does this every time you toggle the visibility of the UITableView causing the spacing to
// grow a little each time, which you weren't testing at all were you? So there you have it, the stupid reason we integer align here.
//
// The same technically applies to the footer, though that could hardly matter less. We just do it for fun.
Layout.LayoutChildIntoBoundingRegion(e, new Rectangle(0, 0, width, Math.Ceiling(request.Request.Height)));
Device.BeginInvokeOnMainThread(() =>
{
if (_headerRenderer != null)
{
Control.TableHeaderView = _headerRenderer.NativeView;
}
});
}
if (_footerRenderer != null)
{
var e = _footerRenderer.Element;
var request = e.Measure(width, height, MeasureFlags.IncludeMargins);
Layout.LayoutChildIntoBoundingRegion(e, new Rectangle(0, 0, width, Math.Ceiling(request.Request.Height)));
Device.BeginInvokeOnMainThread(() =>
{
if (_footerRenderer != null)
{
Control.TableFooterView = _footerRenderer.NativeView;
}
});
}
if (_requestedScroll != null && Superview != null)
{
var request = _requestedScroll;
_requestedScroll = null;
OnScrollToRequested(this, request);
}
if (_previousFrame != Frame)
{
_previousFrame = Frame;
_insetTracker?.UpdateInsets();
}
}
void LayoutSubviews()
{
if (_requestedScroll != null && Superview != null)
{
var request = _requestedScroll;
_requestedScroll = null;
OnScrollToRequested(this, request);
}
}
private void Element_ScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
//TODO: Animate Support
//TODO: Support Position
var scrollArgs = (ITemplatedItemsListScrollToRequestedEventArgs)e;
Control.ScrollIntoView(scrollArgs.Item);
}
public void SetElement(VisualElement element)
{
_requestedScroll = null;
var oldElement = Element;
Element = element;
if (oldElement != null)
{
oldElement.PropertyChanged -= HandlePropertyChanged;
((ScrollView)oldElement).ScrollToRequested -= OnScrollToRequested;
}
if (element != null)
{
element.PropertyChanged += HandlePropertyChanged;
((ScrollView)element).ScrollToRequested += OnScrollToRequested;
if (_packager == null)
{
_packager = new VisualElementPackager(this);
_packager.Load();
_tracker = new VisualElementTracker(this);
_tracker.NativeControlUpdated += OnNativeControlUpdated;
_events = new EventTracker(this);
_events.LoadEvents(this);
_insetTracker = new KeyboardInsetTracker(this, () => Window, insets => ContentInset = ScrollIndicatorInsets = insets, point =>
{
var offset = ContentOffset;
offset.Y += point.Y;
SetContentOffset(offset, true);
});
}
UpdateDelaysContentTouches();
UpdateContentSize();
UpdateBackgroundColor();
UpdateIsEnabled();
UpdateVerticalScrollBarVisibility();
UpdateHorizontalScrollBarVisibility();
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
EffectUtilities.RegisterEffectControlProvider(this, oldElement, element);
if (element != null)
{
element.SendViewInitialized(this);
}
if (!string.IsNullOrEmpty(element.AutomationId))
{
AccessibilityIdentifier = element.AutomationId;
}
}
}
protected override void OnLayout(bool changed, int l, int t, int r, int b)
{
base.OnLayout(changed, l, t, r, b);
if (_pendingScrollTo != null)
{
OnScrollToRequested(this, _pendingScrollTo);
_pendingScrollTo = null;
}
}
protected virtual void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (!IsAttached)
{
_pendingScrollTo = e;
return;
}
Cell cell; // TODO: this is not used at current version. If used individual size, this must be used.
int position;
var scrollArgs = (ITemplatedItemsListScrollToRequestedEventArgs)e;
if (scrollArgs.Item == null)
{
if (e.Position == ScrollToPosition.Start)
{
ExecuteScroll(0, e);
}
else
{
ExecuteScroll(Adapter.ItemCount - 1, e);
}
return;
}
var templatedItems = TemplatedItemsView.TemplatedItems;
if (Element.IsGroupingEnabled)
{
var results = templatedItems.GetGroupAndIndexOfItem(scrollArgs.Group, scrollArgs.Item);
if (results.Item1 == -1 || results.Item2 == -1)
{
return;
}
var group = templatedItems.GetGroup(results.Item1);
cell = group[results.Item2];
position = templatedItems.GetGlobalIndexForGroup(group) + results.Item2 + 1;
}
else
{
position = templatedItems.GetGlobalIndexOfItem(scrollArgs.Item);
if (position == -1)
{
return;
}
cell = templatedItems[position];
}
ExecuteScroll(position, e);
}
public void SetElement(VisualElement element)
{
this.requestedScroll = null;
VisualElement visualElement = this.Element;
this.Element = element;
if (visualElement != null)
{
visualElement.PropertyChanged -= new PropertyChangedEventHandler(this.HandlePropertyChanged);
((IScrollViewController)visualElement).ScrollToRequested -= new EventHandler <ScrollToRequestedEventArgs>(this.OnScrollToRequested);
}
if (element != null)
{
element.PropertyChanged += new PropertyChangedEventHandler(this.HandlePropertyChanged);
((IScrollViewController)element).ScrollToRequested += new EventHandler <ScrollToRequestedEventArgs>(this.OnScrollToRequested);
if (this.packager == null)
{
//this.DelaysContentTouches = true;
this.packager = new VisualElementPackager(this);
this.packager.Load();
this.tracker = new VisualElementTracker(this);
this.tracker.NativeControlUpdated += new EventHandler(this.OnNativeControlUpdated);
this.events = new EventTracker(this);
this.events.LoadEvents(this);
// TODO: WT.?
/*
* this.insetTracker = new KeyboardInsetTracker(this, () => this.Window, (UIEdgeInsets insets) => {
* UIEdgeInsets uIEdgeInset = insets;
* UIEdgeInsets uIEdgeInset1 = uIEdgeInset;
* this.ScrollIndicatorInsets = uIEdgeInset;
* this.ContentInset = uIEdgeInset1;
* }, (CGPoint point) => {
* CGPoint contentOffset = this.ContentOffset;
* contentOffset.Y = contentOffset.Y + point.Y;
* this.SetContentOffset(contentOffset, true);
* });
*/
}
this.UpdateContentSize();
this.UpdateBackgroundColor();
this.OnElementChanged(new VisualElementChangedEventArgs(visualElement, element));
if (element != null)
{
element.SendViewInitialized(this);
}
}
}
private void OnScrollRequested(object sender, ScrollToRequestedEventArgs args)
{
float toX = Context.ToPixels(args.ScrollX);
float toY = Context.ToPixels(args.ScrollY);
if (args.Mode == ScrollToMode.Element)
{
Point itemPosition = Element.GetScrollPositionForElement(args.Element as VisualElement, args.Position);
toX = Context.ToPixels(itemPosition.X);
toY = Context.ToPixels(itemPosition.Y);
}
_zoomLayout.PanTo(toX, toY, args.ShouldAnimate);
}
void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (Superview == null)
{
_requestedScroll = e;
return;
}
Point scrollPoint = (e.Mode == ScrollToMode.Position)
? new Point(e.ScrollX, Element.Height - e.ScrollY)
: ScrollView.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
ContentView.ScrollToPoint(scrollPoint.ToPointF());
ScrollView.SendScrollFinished();
}
void OnScrollRequested(object sender, ScrollToRequestedEventArgs e)
{
var x = e.ScrollX;
var y = e.ScrollY;
if (e.Mode == ScrollToMode.Element)
{
Point itemPosition = (Element as IScrollViewController).GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = itemPosition.X;
y = itemPosition.Y;
}
Rect region = new Rectangle(x, y, Element.Width, Element.Height).ToPixel();
Control.ScrollTo(region, e.ShouldAnimate);
}
public override void LayoutSubviews()
{
base.LayoutSubviews();
if (_requestedScroll != null && Superview != null)
{
var request = _requestedScroll;
_requestedScroll = null;
OnScrollToRequested(this, request);
}
if (_previousFrame != Frame)
{
_previousFrame = Frame;
}
}
void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
_checkedForRtlScroll = true;
if (Superview == null)
{
_requestedScroll = e;
return;
}
PointF newOffset = PointF.Empty;
if (e.Mode == ScrollToMode.Position)
{
newOffset = new PointF((nfloat)e.ScrollX, (nfloat)e.ScrollY);
}
else
{
var positionOnScroll = ScrollView.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
positionOnScroll.X = positionOnScroll.X.Clamp(0, ContentSize.Width - Bounds.Size.Width);
positionOnScroll.Y = positionOnScroll.Y.Clamp(0, ContentSize.Height - Bounds.Size.Height);
switch (ScrollView.Orientation)
{
case ScrollOrientation.Horizontal:
newOffset = new PointF((nfloat)positionOnScroll.X, ContentOffset.Y);
break;
case ScrollOrientation.Vertical:
newOffset = new PointF(ContentOffset.X, (nfloat)positionOnScroll.Y);
break;
case ScrollOrientation.Both:
newOffset = new PointF((nfloat)positionOnScroll.X, (nfloat)positionOnScroll.Y);
break;
}
}
var sameOffset = newOffset == ContentOffset;
SetContentOffset(newOffset, e.ShouldAnimate);
if (!e.ShouldAnimate || sameOffset)
{
ScrollView.SendScrollFinished();
}
}
async void OnScrollRequestedAsync(object sender, ScrollToRequestedEventArgs e)
{
var x = e.ScrollX;
var y = e.ScrollY;
if (e.Mode == ScrollToMode.Element)
{
var itemPosition = (Element as IScrollViewController).GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = itemPosition.X;
y = itemPosition.Y;
}
var region = new Xamarin.Forms.Rectangle(x, y, Element.Width, Element.Height).ToPixel();
await ScrollToAsync(region, e.ShouldAnimate).ConfigureAwait(false);
Element.SendScrollFinished();
}
async void OnScrollRequested(object sender, ScrollToRequestedEventArgs e)
{
var x = e.ScrollX;
var y = e.ScrollY;
if (e.Mode == ScrollToMode.Element)
{
Graphics.Point itemPosition = (Element as IScrollViewController).GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = itemPosition.X;
y = itemPosition.Y;
}
ERect region = new Graphics.Rect(x, y, Element.Width, Element.Height).ToEFLPixel();
await Control.ScrollToAsync(region, e.ShouldAnimate);
Element.SendScrollFinished();
}
async void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
ClearRtlScrollCheck();
// Adding items into the view while scrolling to the end can cause it to fail, as
// the items have not actually been laid out and return incorrect scroll position
// values. The ScrollViewRenderer for Android does something similar by waiting up
// to 10ms for layout to occur.
int cycle = 0;
while (Element != null && !Element.IsInNativeLayout)
{
await Task.Delay(TimeSpan.FromMilliseconds(1));
cycle++;
if (cycle >= 10)
{
break;
}
}
if (Element == null)
{
return;
}
double x = e.ScrollX, y = e.ScrollY;
ScrollToMode mode = e.Mode;
if (mode == ScrollToMode.Element)
{
Point pos = Element.GetScrollPositionForElement((VisualElement)e.Element, e.Position);
x = pos.X;
y = pos.Y;
mode = ScrollToMode.Position;
}
if (mode == ScrollToMode.Position)
{
Control.ChangeView(x, y, null, !e.ShouldAnimate);
}
Element.SendScrollFinished();
}
protected override void ExecuteScroll(int targetPosition, ScrollToRequestedEventArgs eventArgs)
{
if (_hCollectionView.IsInfinite)
{
int fixPosition = _hAdapter.GetInitialPosition();
if (targetPosition == Adapter.ItemCount - 1)
{
fixPosition += Adapter.RealItemCount - 1;
}
else
{
fixPosition += targetPosition;
}
base.ExecuteScroll(fixPosition, eventArgs);
return;
}
base.ExecuteScroll(targetPosition, eventArgs);
}
void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
double x = e.ScrollX, y = e.ScrollY;
ScrollToMode mode = e.Mode;
if (mode == ScrollToMode.Element)
{
Point pos = Controller.GetScrollPositionForElement((VisualElement)e.Element, e.Position);
x = pos.X;
y = pos.Y;
mode = ScrollToMode.Position;
}
if (mode == ScrollToMode.Position)
{
Control.ChangeView(x, y, null, !e.ShouldAnimate);
}
}
public void SetElement(VisualElement element)
{
_requestedScroll = null;
var oldElement = Element;
Element = element;
if (oldElement != null)
{
oldElement.PropertyChanged -= HandlePropertyChanged;
((IScrollViewController)oldElement).ScrollToRequested -= OnScrollToRequested;
}
if (element != null)
{
element.PropertyChanged += HandlePropertyChanged;
((IScrollViewController)element).ScrollToRequested += OnScrollToRequested;
if (_packager == null)
{
DelaysContentTouches = true;
_packager = new VisualElementPackager(this);
_packager.Load();
_tracker = new VisualElementTracker(this);
_events = new EventTracker(this);
_events.LoadEvents(this);
}
UpdateContentSize();
UpdateBackgroundColor();
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
Custom.Helpers.RegisterEffectControlProvider(this, oldElement, element);
if (!string.IsNullOrEmpty(element.AutomationId))
{
AccessibilityIdentifier = element.AutomationId;
}
}
}
void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
UpdatePropertyHelper((element, control) =>
{
//if (_animatable == null && e.ShouldAnimate)
// _animatable = new Animatable();
var position = e.Position;
int x = (int)e.ScrollX;
int y = (int)e.ScrollY;
if (e.Mode == ScrollToMode.Element)
{
var itemPosition = element.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = (int)itemPosition.X;
y = (int)itemPosition.Y;
}
if (control.VerticalScroll.Value == y && control.HorizontalScroll.Value == x)
{
return;
}
/*if (e.ShouldAnimate)
* {
* var animation = new Animation(v => { UpdateScrollOffset(GetDistance(Control.ViewportWidth, x, v), GetDistance(Control.ViewportHeight, y, v)); });
*
* animation.Commit(_animatable, "ScrollTo", length: 500, easing: Easing.CubicInOut, finished: (v, d) =>
* {
* UpdateScrollOffset(x, y);
* element.SendScrollFinished();
* });
* }
* else*/
{
UpdateScrollOffset(x, y);
element.SendScrollFinished();
}
});
}
public void SetElement(VisualElement element)
{
_requestedScroll = null;
var oldElement = Element;
Element = element;
if (oldElement != null)
{
oldElement.PropertyChanged -= OnElementPropertyChanged;
((ScrollView)oldElement).ScrollToRequested -= OnScrollToRequested;
}
if (element != null)
{
element.PropertyChanged += OnElementPropertyChanged;
((ScrollView)element).ScrollToRequested += OnScrollToRequested;
if (_tracker == null)
{
PackContent();
_events = new EventTracker(this);
_events.LoadEvents(this);
_tracker = new VisualElementTracker(this);
_tracker.NativeControlUpdated += OnNativeControlUpdated;
}
UpdateContentSize();
UpdateBackgroundColor();
UpdateBackground();
UpdateVerticalScrollBarVisibility();
UpdateHorizontalScrollBarVisibility();
UpdateOrientation();
RaiseElementChanged(new VisualElementChangedEventArgs(oldElement, element));
}
ResetNativeNonScroll();
}
void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (_animatable == null && e.ShouldAnimate)
{
_animatable = new Animatable();
}
ScrollToPosition position = e.Position;
double x = e.ScrollX;
double y = e.ScrollY;
if (e.Mode == ScrollToMode.Element)
{
Point itemPosition = Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = itemPosition.X;
y = itemPosition.Y;
}
if (Control.VerticalOffset == y && Control.HorizontalOffset == x)
{
return;
}
if (e.ShouldAnimate)
{
var animation = new Animation(v => { UpdateScrollOffset(GetDistance(Control.ViewportWidth, x, v), GetDistance(Control.ViewportHeight, y, v)); });
animation.Commit(_animatable, "ScrollTo", length: 500, easing: Easing.CubicInOut, finished: (v, d) =>
{
UpdateScrollOffset(x, y);
Controller.SendScrollFinished();
});
}
else
{
UpdateScrollOffset(x, y);
Controller.SendScrollFinished();
}
}
private void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
double x = e.ScrollX, y = e.ScrollY;
ScrollToMode mode = e.Mode;
if (mode == ScrollToMode.Element)
{
Point pos = Controller.GetScrollPositionForElement((VisualElement)e.Element, e.Position);
x = pos.X;
y = pos.Y;
mode = ScrollToMode.Position;
}
if (mode == ScrollToMode.Position)
{
Control.Hadjustment.Value = x;
Control.Vadjustment.Value = y;
}
Controller.SendScrollFinished();
}
void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (Superview == null)
{
_requestedScroll = e;
return;
}
if (e.Mode == ScrollToMode.Position)
{
SetContentOffset(new PointF((nfloat)e.ScrollX, (nfloat)e.ScrollY), e.ShouldAnimate);
}
else
{
var positionOnScroll = Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
positionOnScroll.X = positionOnScroll.X.Clamp(0, ContentSize.Width - Bounds.Size.Width);
positionOnScroll.Y = positionOnScroll.Y.Clamp(0, ContentSize.Height - Bounds.Size.Height);
switch (ScrollView.Orientation)
{
case ScrollOrientation.Horizontal:
SetContentOffset(new PointF((nfloat)positionOnScroll.X, ContentOffset.Y), e.ShouldAnimate);
break;
case ScrollOrientation.Vertical:
SetContentOffset(new PointF(ContentOffset.X, (nfloat)positionOnScroll.Y), e.ShouldAnimate);
break;
case ScrollOrientation.Both:
SetContentOffset(new PointF((nfloat)positionOnScroll.X, (nfloat)positionOnScroll.Y), e.ShouldAnimate);
break;
}
}
if (!e.ShouldAnimate)
{
Controller.SendScrollFinished();
}
}
private void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (this.Superview == null)
{
this.requestedScroll = e;
return;
}
if (e.Mode != ScrollToMode.Position)
{
Point scrollPositionForElement = this.Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
if (scrollView.Orientation != ScrollOrientation.Horizontal)
{
//TODO: Scroll to Position
//VerticalScroller.FloatValue = e.Position;
//SetContentOffset(new CGPoint(contentOffset.X, (nfloat)scrollPositionForElement.Y), e.ShouldAnimate);
}
else
{
// TODO: Scroll to Position
//HorizontalScroller.FloatValue = e.Position;
//nfloat x = (nfloat)scrollPositionForElement.X;
//SetContentOffset(new CGPoint(x, contentOffset.Y), e.ShouldAnimate);
}
}
else
{
VerticalScroller.FloatValue = (float)e.ScrollY;
HorizontalScroller.FloatValue = (float)e.ScrollX;
//this.SetContentOffset(new CGPoint((nfloat)e.ScrollX, (nfloat)e.ScrollY), e.ShouldAnimate);
}
if (!e.ShouldAnimate)
{
this.Controller.SendScrollFinished();
}
}
void ListView_ScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (Control == null)
{
return;
}
var oe = (ITemplatedItemsListScrollToRequestedEventArgs)e;
var item = oe.Item;
var group = oe.Group;
switch (e.Position)
{
case ScrollToPosition.Start:
Control.Send(Ooui.Message.Set(Control.Id, "scrollTop", 0));
break;
case ScrollToPosition.End:
Control.Send(Ooui.Message.Set(Control.Id, "scrollTop", new Ooui.Message.PropertyReference {
TargetId = Control.Id, Key = "scrollHeight"
}));
break;
}
}
void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
Cell cell;
var args = e as ITemplatedItemsListScrollToRequestedEventArgs;
if (Element.IsGroupingEnabled)
{
var results = Element.TemplatedItems.GetGroupAndIndexOfItem(args.Group, args.Item);
if (results.Item1 == -1 || results.Item2 == -1)
{
return;
}
var group = (Element.TemplatedItems as ITemplatedItemsList <Cell>).GetGroup(results.Item1);
cell = group[results.Item2];
}
else
{
int index = (Element.TemplatedItems as ITemplatedItemsList <Cell>).GetGlobalIndexOfItem(args.Item);
cell = Element.TemplatedItems[index];
}
Control.ApplyScrollTo(cell, e.Position, e.ShouldAnimate);
}
public override void LayoutSubviews()
{
base.LayoutSubviews();
if (Superview != null)
{
if (_requestedScroll != null)
{
var request = _requestedScroll;
_requestedScroll = null;
OnScrollToRequested(this, request);
}
else
{
UpdateFlowDirection();
}
}
if (_previousFrame != Frame)
{
_previousFrame = Frame;
_insetTracker?.UpdateInsets();
}
}
async void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (!_isAttached)
{
return;
}
// 99.99% of the time simply queuing to the end of the execution queue should handle this case.
// However it is possible to end a layout cycle and STILL be layout requested. We want to
// back off until all are done, even if they trigger layout storms over and over. So we back off
// for 10ms tops then move on.
var cycle = 0;
while (IsLayoutRequested)
{
await Task.Delay(TimeSpan.FromMilliseconds(1));
cycle++;
if (cycle >= 10)
{
break;
}
}
var x = (int)Forms.Context.ToPixels(e.ScrollX);
var y = (int)Forms.Context.ToPixels(e.ScrollY);
int currentX = _view.Orientation == ScrollOrientation.Horizontal ? _hScrollView.ScrollX : ScrollX;
int currentY = _view.Orientation == ScrollOrientation.Horizontal ? _hScrollView.ScrollY : ScrollY;
if (e.Mode == ScrollToMode.Element)
{
Point itemPosition = Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = (int)Forms.Context.ToPixels(itemPosition.X);
y = (int)Forms.Context.ToPixels(itemPosition.Y);
}
if (e.ShouldAnimate)
{
ValueAnimator animator = ValueAnimator.OfFloat(0f, 1f);
animator.SetDuration(1000);
animator.Update += (o, animatorUpdateEventArgs) =>
{
var v = (double)animatorUpdateEventArgs.Animation.AnimatedValue;
int distX = GetDistance(currentX, x, v);
int distY = GetDistance(currentY, y, v);
if (_view == null)
{
// This is probably happening because the page with this Scroll View
// was popped off the stack during animation
animator.Cancel();
return;
}
if (_view.Orientation == ScrollOrientation.Horizontal)
{
_hScrollView.ScrollTo(distX, distY);
}
else
{
ScrollTo(distX, distY);
}
};
animator.AnimationEnd += delegate
{
if (Controller == null)
{
return;
}
Controller.SendScrollFinished();
};
animator.Start();
}
else
{
if (_view.Orientation == ScrollOrientation.Horizontal)
{
_hScrollView.ScrollTo(x, y);
}
else
{
ScrollTo(x, y);
}
Controller.SendScrollFinished();
}
}
async void OnScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
if (!_isAttached)
{
return;
}
// 99.99% of the time simply queuing to the end of the execution queue should handle this case.
// However it is possible to end a layout cycle and STILL be layout requested. We want to
// back off until all are done, even if they trigger layout storms over and over. So we back off
// for 10ms tops then move on.
var cycle = 0;
while (IsLayoutRequested)
{
await Task.Delay(TimeSpan.FromMilliseconds(1));
cycle++;
if (cycle >= 10)
break;
}
var x = (int)Forms.Context.ToPixels(e.ScrollX);
var y = (int)Forms.Context.ToPixels(e.ScrollY);
int currentX = _view.Orientation == ScrollOrientation.Horizontal ? _hScrollView.ScrollX : ScrollX;
int currentY = _view.Orientation == ScrollOrientation.Horizontal ? _hScrollView.ScrollY : ScrollY;
if (e.Mode == ScrollToMode.Element)
{
Point itemPosition = Controller.GetScrollPositionForElement(e.Element as VisualElement, e.Position);
x = (int)Forms.Context.ToPixels(itemPosition.X);
y = (int)Forms.Context.ToPixels(itemPosition.Y);
}
if (e.ShouldAnimate)
{
ValueAnimator animator = ValueAnimator.OfFloat(0f, 1f);
animator.SetDuration(1000);
animator.Update += (o, animatorUpdateEventArgs) =>
{
var v = (double)animatorUpdateEventArgs.Animation.AnimatedValue;
int distX = GetDistance(currentX, x, v);
int distY = GetDistance(currentY, y, v);
if (_view == null)
{
// This is probably happening because the page with this Scroll View
// was popped off the stack during animation
animator.Cancel();
return;
}
if (_view.Orientation == ScrollOrientation.Horizontal)
_hScrollView.ScrollTo(distX, distY);
else
ScrollTo(distX, distY);
};
animator.AnimationEnd += delegate
{
if (Controller == null)
return;
Controller.SendScrollFinished();
};
animator.Start();
}
else
{
if (_view.Orientation == ScrollOrientation.Horizontal)
_hScrollView.ScrollTo(x, y);
else
ScrollTo(x, y);
Controller.SendScrollFinished();
}
}
void OnElementScrollToRequested(object sender, ScrollToRequestedEventArgs e)
{
var scrollArgs = (ITemplatedItemsListScrollToRequestedEventArgs)e;
ScrollTo(scrollArgs.Group, scrollArgs.Item, e.Position, e.ShouldAnimate);
}
private void ListViewControllerOnScrollToRequested(object sender, ScrollToRequestedEventArgs scrollToRequestedEventArgs)
{
}
