public override AView OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
if (Page != null)
{
_visualElementRenderer = Android.Platform.CreateRenderer(Page, ChildFragmentManager);
Android.Platform.SetRenderer(Page, _visualElementRenderer);
_pageContainer = new PageContainer(Forms.Context, _visualElementRenderer, true);
return _pageContainer;
}
return null;
}
public VisualElementPackager(IVisualElementRenderer renderer, int row = 0, int rowSpan = 0, int column = 0, int columnSpan = 0) : this(renderer)
{
_row = row;
_rowSpan = rowSpan;
_column = column;
_columnSpan = columnSpan;
}
public static void SetRenderer(BindableObject bindable, IVisualElementRenderer value)
{
var assembly = Assembly.Load("Xamarin.Forms.Platform.iOS");
var type = assembly.GetType("Xamarin.Forms.Platform.iOS.Platform");
var method = type.GetMethod("SetRenderer", BindingFlags.Public | BindingFlags.Static);
method.Invoke(null, new Object[] { bindable, value });
}
public VisualElementPackager(IVisualElementRenderer renderer)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
Renderer = renderer;
renderer.ElementChanged += OnRendererElementChanged;
SetElement(null, renderer.Element);
}
internal ModalWrapper(IVisualElementRenderer modal)
{
_modal = modal;
View.BackgroundColor = UIColor.White;
View.AddSubview(modal.ViewController.View);
AddChildViewController(modal.ViewController);
modal.ViewController.DidMoveToParentViewController(this);
}
public EventTracker(IVisualElementRenderer renderer)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
_collectionChangedHandler = ModelGestureRecognizersOnCollectionChanged;
_renderer = renderer;
_renderer.ElementChanged += OnElementChanged;
}
void PushRenderer(IVisualElementRenderer renderer)
{
Type rendererType = renderer.GetType();
Stack<IVisualElementRenderer> renderers;
if (!_freeRenderers.TryGetValue(rendererType, out renderers))
_freeRenderers[rendererType] = renderers = new Stack<IVisualElementRenderer>();
renderers.Push(renderer);
}
public ViewCellContainer(Context context, IVisualElementRenderer view, ViewCell viewCell, View parent, BindableProperty unevenRows, BindableProperty rowHeight) : base(context)
{
_view = view;
_parent = parent;
_unevenRows = unevenRows;
_rowHeight = rowHeight;
_viewCell = viewCell;
AddView(view.ViewGroup);
UpdateIsEnabled();
}
public RendererPool(IVisualElementRenderer renderer, VisualElement oldElement)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
if (oldElement == null)
throw new ArgumentNullException("oldElement");
_oldElement = oldElement;
_parent = renderer;
}
public VisualElementPackager(IVisualElementRenderer renderer)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
_panel = renderer.ContainerElement as Panel;
if (_panel == null)
throw new ArgumentException("Renderer's container element must be a Panel or Panel subclass");
_renderer = renderer;
}
public VisualElementPackager(IVisualElementRenderer renderer)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
_childAddedHandler = OnChildAdded;
_childRemovedHandler = OnChildRemoved;
_childReorderedHandler = OnChildrenReordered;
_renderer = renderer;
_renderer.ElementChanged += (sender, args) => SetElement(args.OldElement, args.NewElement);
}
public VisualElementTracker(IVisualElementRenderer renderer)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
_propertyChangedHandler = HandlePropertyChanged;
_sizeChangedEventHandler = HandleSizeChanged;
_batchCommittedHandler = HandleRedrawNeeded;
Renderer = renderer;
renderer.ElementChanged += OnRendererElementChanged;
SetElement(null, renderer.Element);
}
public void Dispose()
{
if (_disposed)
return;
_disposed = true;
SetElement(_element, null);
if (_renderer != null)
{
_renderer.ElementChanged -= RendererOnElementChanged;
_renderer.ViewGroup.RemoveOnAttachStateChangeListener(AttachTracker.Instance);
_renderer = null;
_context = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (_isDisposed)
return;
if (disposing)
{
SetElement(_element, null);
if (Renderer != null)
{
Renderer.ElementChanged -= OnRendererElementChanged;
Renderer = null;
}
}
_isDisposed = true;
}
public VisualElementTracker(IVisualElementRenderer renderer)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
_batchCommittedHandler = HandleRedrawNeeded;
_propertyChangedHandler = HandlePropertyChanged;
_renderer = renderer;
_context = renderer.ViewGroup.Context;
_renderer.ElementChanged += RendererOnElementChanged;
VisualElement view = renderer.Element;
SetElement(null, view);
renderer.ViewGroup.SetCameraDistance(3600);
renderer.ViewGroup.AddOnAttachStateChangeListener(AttachTracker.Instance);
}
void ClearRenderers(IVisualElementRenderer renderer)
{
if (renderer == null)
return;
var subviews = renderer.NativeView.Subviews;
for (var i = 0; i < subviews.Length; i++)
{
var childRenderer = subviews[i] as IVisualElementRenderer;
if (childRenderer != null)
{
PushRenderer(childRenderer);
if (ReferenceEquals(childRenderer, Platform.GetRenderer(childRenderer.Element)))
childRenderer.Element.ClearValue(Platform.RendererProperty);
}
subviews[i].RemoveFromSuperview();
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
return;
_disposed = true;
if (disposing)
{
SetElement(_element, null);
if (_layer != null)
{
_layer.Dispose();
_layer = null;
}
Renderer.ElementChanged -= OnRendererElementChanged;
Renderer = null;
}
}
public void Dispose()
{
if (_disposed)
return;
_disposed = true;
if (_renderer != null)
{
if (_childViews != null)
{
_childViews.Clear();
_childViews = null;
}
_renderer.Element.ChildAdded -= _childAddedHandler;
_renderer.Element.ChildRemoved -= _childRemovedHandler;
_renderer.Element.ChildrenReordered -= _childReorderedHandler;
_renderer = null;
}
}
public override void OnDestroyView()
{
if (Page != null)
{
IVisualElementRenderer renderer = _visualElementRenderer;
PageContainer container = _pageContainer;
if (container.Handle != IntPtr.Zero && renderer.ViewGroup.Handle != IntPtr.Zero)
{
container.RemoveFromParent();
renderer.ViewGroup.RemoveFromParent();
Page.ClearValue(Android.Platform.RendererProperty);
container.Dispose();
renderer.Dispose();
}
}
_visualElementRenderer = null;
_pageContainer = null;
base.OnDestroyView();
}
void AddChild(VisualElement view, IVisualElementRenderer oldRenderer = null, RendererPool pool = null, bool sameChildren = false)
{
Performance.Start();
if (_childViews == null)
_childViews = new List<IVisualElementRenderer>();
IVisualElementRenderer renderer = oldRenderer;
if (pool != null)
renderer = pool.GetFreeRenderer(view);
if (renderer == null)
{
Performance.Start("New renderer");
renderer = Platform.CreateRenderer(view);
Performance.Stop("New renderer");
}
if (renderer == oldRenderer)
{
Platform.SetRenderer(renderer.Element, null);
renderer.SetElement(view);
}
Performance.Start("Set renderer");
Platform.SetRenderer(view, renderer);
Performance.Stop("Set renderer");
Performance.Start("Add view");
if (!sameChildren)
{
_renderer.ViewGroup.AddView(renderer.ViewGroup);
_childViews.Add(renderer);
}
Performance.Stop("Add view");
Performance.Stop();
}
void SetElement(VisualElement oldElement, VisualElement newElement)
{
Performance.Start(out string reference);
var sameChildrenTypes = false;
ReadOnlyCollection <Element> newChildren = null, oldChildren = null;
RendererPool pool = null;
if (oldElement != null)
{
oldElement.ChildAdded -= _childAddedHandler;
oldElement.ChildRemoved -= _childRemovedHandler;
oldElement.ChildrenReordered -= _childReorderedHandler;
oldChildren = ((IElementController)oldElement).LogicalChildren;
if (newElement != null)
{
sameChildrenTypes = true;
newChildren = ((IElementController)newElement).LogicalChildren;
if (oldChildren.Count == newChildren.Count)
{
for (var i = 0; i < oldChildren.Count; i++)
{
if (oldChildren[i].GetType() != newChildren[i].GetType())
{
sameChildrenTypes = false;
break;
}
}
}
else
{
sameChildrenTypes = false;
}
}
else
{
for (var i = 0; i < oldChildren.Count; i++)
{
RemoveChild((VisualElement)oldChildren[i]);
}
}
if (!sameChildrenTypes)
{
_childViews = new List <IVisualElementRenderer>();
pool = new RendererPool(_renderer, oldElement);
pool.ClearChildrenRenderers();
}
}
if (newElement != null)
{
Performance.Start(reference, "Setup");
newElement.ChildAdded += _childAddedHandler;
newElement.ChildRemoved += _childRemovedHandler;
newElement.ChildrenReordered += _childReorderedHandler;
newChildren = newChildren ?? ((IElementController)newElement).LogicalChildren;
for (var i = 0; i < newChildren.Count; i++)
{
IVisualElementRenderer oldRenderer = null;
if (oldChildren != null && sameChildrenTypes && _childViews != null)
{
oldRenderer = _childViews[i];
}
AddChild((VisualElement)newChildren[i], oldRenderer, pool, sameChildrenTypes);
}
#if DEBUG
//if (renderer.Element.LogicalChildren.Any() && renderer.ViewGroup.ChildCount != renderer.Element.LogicalChildren.Count)
// throw new InvalidOperationException ("SetElement did not create the correct number of children");
#endif
EnsureChildOrder();
Performance.Stop(reference, "Setup");
}
Performance.Stop(reference);
}
protected void SetDefaultBackgroundColor(IVisualElementRenderer renderer)
{
if (ChildView.BackgroundColor == Color.Default)
{
TypedArray colors = Context.Theme.ObtainStyledAttributes(new[] { global::Android.Resource.Attribute.ColorBackground });
renderer.ViewGroup.SetBackgroundColor(new global::Android.Graphics.Color(colors.GetColor(0, 0)));
}
}
protected override Windows.Foundation.Size ArrangeOverride(Windows.Foundation.Size finalSize)
{
if (Element == null || finalSize.Width * finalSize.Height == 0)
{
return(finalSize);
}
Element.IsInNativeLayout = true;
var myRect = new Rect(0, 0, finalSize.Width, finalSize.Height);
if (Control != null)
{
Control.Arrange(myRect);
}
List <UIElement> arrangedChildren = null;
for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
{
var child = ElementController.LogicalChildren[i] as VisualElement;
if (child == null)
{
continue;
}
IVisualElementRenderer renderer = Platform.GetRenderer(child);
if (renderer == null)
{
continue;
}
Rectangle bounds = child.Bounds;
renderer.ContainerElement.Arrange(new Rect(bounds.X, bounds.Y, Math.Max(0, bounds.Width), Math.Max(0, bounds.Height)));
if (ArrangeNativeChildren)
{
if (arrangedChildren == null)
{
arrangedChildren = new List <UIElement>();
}
arrangedChildren.Add(renderer.ContainerElement);
}
}
if (ArrangeNativeChildren)
{
// in the event that a custom renderer has added native controls,
// we need to be sure to arrange them so that they are laid out.
var nativeChildren = Children;
for (int i = 0; i < nativeChildren.Count; i++)
{
var nativeChild = nativeChildren[i];
if (arrangedChildren?.Contains(nativeChild) == true)
{
// don't try to rearrange renderers that were just arranged,
// lest you suffer a layout cycle
continue;
}
else
{
nativeChild.Arrange(myRect);
}
}
}
Element.IsInNativeLayout = false;
return(finalSize);
}
protected virtual void AddChildView(VisualElement childView)
{
_pageContainer = null;
Page page = childView as NavigationPage ?? (Page)(childView as TabbedPage);
if (page == null)
{
// The thing we're adding is not a NavigationPage or TabbedPage, so we can just use the old AddChildView
if (_currentFragment != null)
{
if (!_parent.IsAttachedToRoot())
{
return;
}
// But first, if the previous occupant of this container was a fragment, we need to remove it properly
FragmentTransaction transaction = FragmentManager.BeginTransactionEx();
transaction.RemoveEx(_currentFragment);
transaction.SetTransitionEx((int)FragmentTransit.None);
if (IsAttachedToWindow)
{
ExecuteTransaction(transaction);
}
else
{
_transaction = transaction;
}
_currentFragment = null;
}
IVisualElementRenderer renderer = APlatform.GetRenderer(childView);
if (renderer == null)
{
APlatform.SetRenderer(childView, renderer = APlatform.CreateRenderer(childView, Context));
}
if (renderer.View.Parent != this)
{
if (renderer.View.Parent != null)
{
renderer.View.RemoveFromParent();
}
SetDefaultBackgroundColor(renderer);
AddView(renderer.View);
renderer.UpdateLayout();
}
}
else
{
if (!_parent.IsAttachedToRoot())
{
return;
}
// The renderers for NavigationPage and TabbedPage both host fragments, so they need to be wrapped in a
// FragmentContainer in order to get isolated fragment management
Fragment fragment = FragmentContainer.CreateInstance(page);
var fc = fragment as FragmentContainer;
fc?.SetOnCreateCallback(pc =>
{
_pageContainer = pc;
UpdateFlowDirection();
SetDefaultBackgroundColor(pc.Child);
});
FragmentTransaction transaction = FragmentManager.BeginTransactionEx();
if (_currentFragment != null)
{
transaction.RemoveEx(_currentFragment);
}
transaction.AddEx(Id, fragment);
transaction.SetTransitionEx((int)FragmentTransit.None);
if (IsAttachedToWindow)
{
ExecuteTransaction(transaction);
}
else
{
_transaction = transaction;
}
_currentFragment = fragment;
}
}
internal EditText GetEditText(IVisualElementRenderer renderer)
{
var viewGroup = renderer?.View as ViewGroup;
return(viewGroup?.GetChildAt(0) as EditText);
}
public static void SetRenderer(BindableObject bindableObject, IVisualElementRenderer renderer)
{
var value = bindableObject.GetValue (RendererProperty);
bindableObject.SetValue (RendererProperty, renderer);
}
void NotifyWrapperAwareDescendants(Element currentView, IVisualElementRenderer currentRenderer)
{
// If any of the child renderers need to handle anything differently because they're in
// a wrapper in a list view, let them know that they're being wrapped
var wrapperAwareRenderer = currentRenderer as IWrapperAware;
wrapperAwareRenderer?.NotifyWrapped();
foreach (Element child in currentView.LogicalChildren)
{
var childView = child as View;
if (childView == null)
{
continue;
}
NotifyWrapperAwareDescendants(childView, Platform.GetRenderer(childView));
}
}
public UIDragItem[] HandleDragStarting(View element, IVisualElementRenderer renderer)
{
UIDragItem[] returnValue = null;
SendEventArgs <DragGestureRecognizer>(rec =>
{
if (!rec.CanDrag)
{
return;
}
var args = rec.SendDragStarting(element);
if (args.Cancel)
{
return;
}
if (!args.Handled)
{
UIImage uIImage = null;
string clipDescription = String.Empty;
NSItemProvider itemProvider = null;
if (renderer is IImageVisualElementRenderer iver)
{
uIImage = iver.GetImage()?.Image;
if (uIImage != null)
{
itemProvider = new NSItemProvider(uIImage);
}
else
{
itemProvider = new NSItemProvider(new NSString(""));
}
if (args.Data.Image == null && renderer.Element is IImageElement imageElement)
{
args.Data.Image = imageElement.Source;
}
}
else
{
string text = args.Data.Text ?? clipDescription;
if (String.IsNullOrWhiteSpace(text))
{
itemProvider = new NSItemProvider(renderer.NativeView.ConvertToImage());
}
else
{
itemProvider = new NSItemProvider(new NSString(text));
}
}
var dragItem = new UIDragItem(itemProvider);
dragItem.LocalObject = new CustomLocalStateData()
{
Renderer = renderer,
View = renderer.Element as View,
DataPackage = args.Data
};
returnValue = new UIDragItem[] { dragItem };
}
},
element);
return(returnValue ?? new UIDragItem[0]);
}
public SizedItemContentView(IVisualElementRenderer content, Context context, Func <int> width, Func <int> height)
: base(content, context)
{
_width = width;
_height = height;
}
void AddMenu()
{
if (_basePage == null)
{
return;
}
var menu = _basePage.SlideMenu;
if (menu == null)
{
return;
}
_basePage.HideMenuAction = () => {
if (_dragGesture == null)
{
return;
}
var rect = _dragGesture.GetHidePosition();
_popMenuOverlayRenderer.ViewGroup.Animate()
.X((float)rect.left)
.Y((float)rect.top)
.SetDuration(menu.AnimationDurationMillisecond)
.SetListener(new AnimatorListener(_dragGesture, false))
.Start();
};
_basePage.ShowMenuAction = () => {
if (_dragGesture == null)
{
return;
}
var rect = _dragGesture.GetShowPosition();
_popMenuOverlayRenderer.ViewGroup.Animate()
.X((float)rect.left)
.Y((float)rect.top)
.SetDuration(menu.AnimationDurationMillisecond)
.SetListener(new AnimatorListener(_dragGesture, true))
.Start();
};
if (_popMenuOverlayRenderer == null)
{
_popMenuOverlayRenderer = RendererFactory.GetRenderer(menu);
var metrics = _pageRenderer.Resources.DisplayMetrics;
var rootView = _popMenuOverlayRenderer.ViewGroup;
if (_popMenuOverlayRenderer is SlideMenuDroidRenderer)
{
_dragGesture = (_popMenuOverlayRenderer as SlideMenuDroidRenderer).GragGesture;
}
if (_dragGesture == null)
{
return;
}
var rect = _dragGesture.GetHidePosition();
menu.Layout(new Xamarin.Forms.Rectangle(
rect.left / metrics.Density,
rect.top / metrics.Density,
(rect.right - rect.left) / metrics.Density,
(rect.bottom - rect.top) / metrics.Density));
_popMenuOverlayRenderer.UpdateLayout();
_popMenuOverlayRenderer.ViewGroup.Visibility = ViewStates.Visible;
rootView.Layout((int)rect.left, (int)rect.top, (int)rect.right, (int)rect.bottom);
_pageRenderer.ViewGroup.AddView(rootView);
_pageRenderer.ViewGroup.BringChildToFront(rootView);
_dragGesture.NeedShowBackgroundView = (open, alpha) => {
if (open)
{
ShowBackgroundOverlay(alpha);
}
else
{
HideBackgroundOverlay();
}
};
}
}
Task <bool> SwitchContentAsync(Page view, bool animated, bool removed = false)
{
Context.HideKeyboard(this);
IVisualElementRenderer rendererToAdd = Platform.GetRenderer(view);
bool existing = rendererToAdd != null;
if (!existing)
{
Platform.SetRenderer(view, rendererToAdd = Platform.CreateRenderer(view));
}
Page pageToRemove = _current;
IVisualElementRenderer rendererToRemove = pageToRemove == null ? null : Platform.GetRenderer(pageToRemove);
PageContainer containerToRemove = rendererToRemove == null ? null : (PageContainer)rendererToRemove.ViewGroup.Parent;
PageContainer containerToAdd = (PageContainer)rendererToAdd.ViewGroup.Parent ?? new PageContainer(Context, rendererToAdd);
containerToAdd.SetWindowBackground();
_current = view;
((Platform)Element.Platform).NavAnimationInProgress = true;
var tcs = new TaskCompletionSource <bool>();
if (animated)
{
if (s_currentAnimation != null)
{
s_currentAnimation.Cancel();
}
if (removed)
{
// animate out
if (containerToAdd.Parent != this)
{
AddView(containerToAdd, ((IElementController)Element).LogicalChildren.IndexOf(rendererToAdd.Element));
}
else
{
((IPageController)rendererToAdd.Element).SendAppearing();
}
containerToAdd.Visibility = ViewStates.Visible;
if (containerToRemove != null)
{
Action <AndroidAnimation.Animator> done = a =>
{
containerToRemove.Visibility = ViewStates.Gone;
containerToRemove.Alpha = 1;
containerToRemove.ScaleX = 1;
containerToRemove.ScaleY = 1;
RemoveView(containerToRemove);
tcs.TrySetResult(true);
((Platform)Element.Platform).NavAnimationInProgress = false;
VisualElement removedElement = rendererToRemove.Element;
rendererToRemove.Dispose();
if (removedElement != null)
{
Platform.SetRenderer(removedElement, null);
}
};
// should always happen
s_currentAnimation = containerToRemove.Animate().Alpha(0).ScaleX(0.8f).ScaleY(0.8f).SetDuration(250).SetListener(new GenericAnimatorListener {
OnEnd = a =>
{
s_currentAnimation = null;
done(a);
},
OnCancel = done
});
}
}
else
{
bool containerAlreadyAdded = containerToAdd.Parent == this;
// animate in
if (!containerAlreadyAdded)
{
AddView(containerToAdd);
}
else
{
((IPageController)rendererToAdd.Element).SendAppearing();
}
if (existing)
{
Element.ForceLayout();
}
containerToAdd.Alpha = 0;
containerToAdd.ScaleX = containerToAdd.ScaleY = 0.8f;
containerToAdd.Visibility = ViewStates.Visible;
s_currentAnimation = containerToAdd.Animate().Alpha(1).ScaleX(1).ScaleY(1).SetDuration(250).SetListener(new GenericAnimatorListener {
OnEnd = a =>
{
if (containerToRemove != null && containerToRemove.Handle != IntPtr.Zero)
{
containerToRemove.Visibility = ViewStates.Gone;
((IPageController)pageToRemove)?.SendDisappearing();
}
s_currentAnimation = null;
tcs.TrySetResult(true);
((Platform)Element.Platform).NavAnimationInProgress = false;
}
});
}
}
else
{
// just do it fast
if (containerToRemove != null)
{
if (removed)
{
RemoveView(containerToRemove);
}
else
{
containerToRemove.Visibility = ViewStates.Gone;
}
}
if (containerToAdd.Parent != this)
{
AddView(containerToAdd);
}
else
{
((IPageController)rendererToAdd.Element).SendAppearing();
}
if (containerToRemove != null && !removed)
{
((IPageController)pageToRemove).SendDisappearing();
}
if (existing)
{
Element.ForceLayout();
}
containerToAdd.Visibility = ViewStates.Visible;
tcs.SetResult(true);
((Platform)Element.Platform).NavAnimationInProgress = false;
}
return(tcs.Task);
}
protected override void Dispose(bool disposing)
{
if (disposing && !_disposed)
{
_disposed = true;
if (_titleViewRenderer != null)
{
Android.Platform.ClearRenderer(_titleViewRenderer.View);
_titleViewRenderer.Dispose();
_titleViewRenderer = null;
}
_toolbar.RemoveView(_titleView);
_titleView?.Dispose();
_titleView = null;
_toolbar.RemoveView(_titleIconView);
_titleIconView?.Dispose();
_titleIconView = null;
_imageSource = null;
if (_toolbarTracker != null)
{
_toolbarTracker.CollectionChanged -= ToolbarTrackerOnCollectionChanged;
_toolbarTracker.Target = null;
_toolbarTracker = null;
}
if (_toolbar != null)
{
_toolbar.SetNavigationOnClickListener(null);
_toolbar.Dispose();
_toolbar = null;
}
if (_drawerLayout != null && _drawerListener != null)
{
_drawerLayout.RemoveDrawerListener(_drawerListener);
}
if (_drawerListener != null)
{
_drawerListener.Dispose();
_drawerListener = null;
}
if (_drawerToggle != null)
{
_drawerToggle.Dispose();
_drawerToggle = null;
}
if (_backgroundDrawable != null)
{
_backgroundDrawable.Dispose();
_backgroundDrawable = null;
}
Current = null;
// We dispose the child renderers after cleaning up everything related to DrawerLayout in case
// one of the children is a MasterDetailPage (which may dispose of the DrawerLayout).
if (Element != null)
{
foreach (Element element in PageController.InternalChildren)
{
var child = element as VisualElement;
if (child == null)
{
continue;
}
IVisualElementRenderer renderer = Android.Platform.GetRenderer(child);
renderer?.Dispose();
}
var navController = NavigationPageController;
navController.PushRequested -= OnPushed;
navController.PopRequested -= OnPopped;
navController.PopToRootRequested -= OnPoppedToRoot;
navController.InsertPageBeforeRequested -= OnInsertPageBeforeRequested;
navController.RemovePageRequested -= OnRemovePageRequested;
}
Device.Info.PropertyChanged -= DeviceInfoPropertyChanged;
// API only exists on newer android YAY
if ((int)Build.VERSION.SdkInt >= 17)
{
FragmentManager fm = FragmentManager;
if (!fm.IsDestroyed)
{
FragmentTransaction trans = fm.BeginTransactionEx();
foreach (Fragment fragment in _fragmentStack)
{
trans.RemoveEx(fragment);
}
trans.CommitAllowingStateLossEx();
fm.ExecutePendingTransactionsEx();
}
}
}
base.Dispose(disposing);
}
static bool IsDrawableSourceValid(this IVisualElementRenderer renderer, BindableObject bindable, out BindableObject element)
{
if ((renderer is IDisposedState disposed && disposed.IsDisposed) || (renderer != null && renderer.View == null))
{
element = null;
}
public VisualElementPackager(IVisualElementRenderer renderer) : this(renderer, null)
{
}
public static void SetRenderer(VisualElement bindable, IVisualElementRenderer value)
{
bindable.SetValue(RendererProperty, value);
}
protected void AddChildView(VisualElement childView)
{
IVisualElementRenderer renderer = Platform.GetOrCreateRenderer(childView);
this.PackEnd(renderer.NativeView);
}
public static void SetRenderer(VisualElement element, IVisualElementRenderer value)
{
element.SetValue(RendererProperty, value);
element.IsPlatformEnabled = value != null;
}
protected override void Dispose(bool disposing)
{
// check inset tracker for null to
if (disposing && _insetTracker != null)
{
_insetTracker.Dispose();
_insetTracker = null;
var viewsToLookAt = new Stack <UIView>(Subviews);
while (viewsToLookAt.Count > 0)
{
var view = viewsToLookAt.Pop();
var viewCellRenderer = view as ViewCellRenderer.ViewTableCell;
if (viewCellRenderer != null)
{
viewCellRenderer.Dispose();
}
else
{
foreach (var child in view.Subviews)
{
viewsToLookAt.Push(child);
}
}
}
if (Element != null)
{
var templatedItems = TemplatedItemsView.TemplatedItems;
templatedItems.CollectionChanged -= OnCollectionChanged;
templatedItems.GroupedCollectionChanged -= OnGroupedCollectionChanged;
}
if (_tableViewController != null)
{
_tableViewController.Dispose();
_tableViewController = null;
}
}
if (disposing)
{
if (_headerRenderer != null)
{
var platform = _headerRenderer.Element.Platform as Platform;
if (platform != null)
{
platform.DisposeModelAndChildrenRenderers(_headerRenderer.Element);
}
_headerRenderer = null;
}
if (_footerRenderer != null)
{
var platform = _footerRenderer.Element.Platform as Platform;
if (platform != null)
{
platform.DisposeModelAndChildrenRenderers(_footerRenderer.Element);
}
_footerRenderer = null;
}
var headerView = Controller?.HeaderElement as VisualElement;
if (headerView != null)
{
headerView.MeasureInvalidated -= OnHeaderMeasureInvalidated;
}
Control?.TableHeaderView?.Dispose();
var footerView = Controller?.FooterElement as VisualElement;
if (footerView != null)
{
footerView.MeasureInvalidated -= OnFooterMeasureInvalidated;
}
Control?.TableFooterView?.Dispose();
}
base.Dispose(disposing);
}
protected override void Dispose(bool disposing)
{
if (disposing && !_disposed)
{
_disposed = true;
if (Element != null)
{
PageController.InternalChildren.CollectionChanged -= OnChildrenCollectionChanged;
foreach (Page pageToRemove in Element.Children)
{
TeardownPage(pageToRemove);
}
}
RemoveAllViews();
if (_viewPager != null)
{
_viewPager.ClearOnPageChangeListeners();
_viewPager.Adapter.Dispose();
_viewPager.Dispose();
_viewPager = null;
}
if (_tabLayout != null)
{
_tabLayout.ClearOnTabSelectedListeners();
_tabLayout.Dispose();
_tabLayout = null;
}
if (_bottomNavigationView != null)
{
_bottomNavigationView.SetOnNavigationItemSelectedListener(null);
_bottomNavigationView.Dispose();
_bottomNavigationView = null;
}
if (_relativeLayout != null)
{
_relativeLayout.Dispose();
_relativeLayout = null;
}
if (Element != null)
{
foreach (Page pageToRemove in Element.Children)
{
IVisualElementRenderer pageRenderer = Android.Platform.GetRenderer(pageToRemove);
pageRenderer?.Dispose();
pageToRemove.ClearValue(Android.Platform.RendererProperty);
}
}
_previousPage = null;
}
base.Dispose(disposing);
}
/// <summary>
/// Managest adding and removing the android viewgroup to our actual swiperefreshlayout
/// </summary>
void UpdateContent()
{
if (RefreshView.Content == null)
return;
if (packed != null)
RemoveView(packed.ViewGroup);
packed = Platform.CreateRenderer(RefreshView.Content);
try
{
RefreshView.Content.SetValue(RendererProperty, packed);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Unable to sent renderer property, maybe an issue: " + ex);
}
AddView(packed.ViewGroup, LayoutParams.MatchParent);
}
public ModalContainer(Context context, Page modal) : base(context)
{
_modal = modal;
_backgroundView = new global::Android.Views.View(context);
_backgroundView.SetWindowBackground();
AddView(_backgroundView);
Android.Platform.SetPageContext(modal, context);
_renderer = Android.Platform.CreateRenderer(modal);
Android.Platform.SetRenderer(modal, _renderer);
AddView(_renderer.ViewGroup);
}
public void Update(ViewCell cell)
{
Performance.Start();
var renderer = GetChildAt(0) as IVisualElementRenderer;
var viewHandlerType = Registrar.Registered.GetHandlerTypeForObject(cell.View) ?? typeof(Platform.DefaultRenderer);
var reflectableType = renderer as System.Reflection.IReflectableType;
var rendererType = reflectableType != null?reflectableType.GetTypeInfo().AsType() : (renderer != null ? renderer.GetType() : typeof(System.Object));
if (renderer != null && rendererType == viewHandlerType)
{
Performance.Start("Reuse");
_viewCell = cell;
cell.View.DisableLayout = true;
foreach (VisualElement c in cell.View.Descendants())
{
c.DisableLayout = true;
}
Performance.Start("Reuse.SetElement");
renderer.SetElement(cell.View);
Performance.Stop("Reuse.SetElement");
Platform.SetRenderer(cell.View, _view);
cell.View.DisableLayout = false;
foreach (VisualElement c in cell.View.Descendants())
{
c.DisableLayout = false;
}
var viewAsLayout = cell.View as Layout;
if (viewAsLayout != null)
{
viewAsLayout.ForceLayout();
}
Invalidate();
Performance.Stop("Reuse");
Performance.Stop();
return;
}
RemoveView(_view.View);
Platform.SetRenderer(_viewCell.View, null);
_viewCell.View.IsPlatformEnabled = false;
_view.View.Dispose();
_viewCell = cell;
_view = Platform.CreateRenderer(_viewCell.View);
Platform.SetRenderer(_viewCell.View, _view);
AddView(_view.View);
UpdateIsEnabled();
UpdateWatchForLongPress();
Performance.Stop();
}
protected override void Dispose(bool disposing)
{
if (disposing && !_disposed)
{
_disposed = true;
RemoveAllViews();
if (_renderer != null)
{
_renderer.Dispose();
_renderer = null;
_modal.ClearValue(Android.Platform.RendererProperty);
_modal = null;
}
if (_backgroundView != null)
{
_backgroundView.Dispose();
_backgroundView = null;
}
}
base.Dispose(disposing);
}
/// <summary>
/// Reflection from function Xamarin.Forms.Platform.iOS.Platform.SetRenderer ( BindableObject bindable , IVisualElementRenderer value )
/// </summary>
/// <param name="bindable">The bindable.</param>
/// <param name="value">The value.</param>
private static void SetRenderer ( BindableObject bindable , IVisualElementRenderer value ) {
if ( bindable == null ) {
return;
}
if ( value == null ) {
return;
}
if ( setRendererDelegate == null ) {
var assembly = typeof ( CarouselPageRenderer ).Assembly;
var platformType = assembly.GetType ( "Xamarin.Forms.Platform.iOS.Platform" );
var method = platformType.GetMethod ( "SetRenderer" );
setRendererDelegate = ( SetRendererDelegate ) method.CreateDelegate ( typeof ( SetRendererDelegate ) );
}
setRendererDelegate ( bindable , value );
}
void AddMenu()
{
if (_basePage == null)
return;
var menu = _basePage.SlideMenu;
if (menu == null)
return;
_basePage.HideMenuAction = () => {
if (_dragGesture == null)
return;
var rect = _dragGesture.GetHidePosition ();
_popMenuOverlayRenderer.ViewGroup.Animate ()
.X ((float)rect.left)
.Y ((float)rect.top)
.SetDuration (menu.AnimationDurationMillisecond)
.SetListener (new AnimatorListener (_dragGesture, false))
.Start ();
};
_basePage.ShowMenuAction = () => {
if (_dragGesture == null)
return;
var rect = _dragGesture.GetShowPosition ();
_popMenuOverlayRenderer.ViewGroup.Animate ()
.X ((float)rect.left)
.Y ((float)rect.top)
.SetDuration (menu.AnimationDurationMillisecond)
.SetListener (new AnimatorListener (_dragGesture, true))
.Start ();
};
if (_popMenuOverlayRenderer == null) {
_popMenuOverlayRenderer = RendererFactory.GetRenderer (menu);
var metrics = _pageRenderer.Resources.DisplayMetrics;
var rootView = _popMenuOverlayRenderer.ViewGroup;
if (_popMenuOverlayRenderer is SlideMenuDroidRenderer) {
_dragGesture = (_popMenuOverlayRenderer as SlideMenuDroidRenderer).GragGesture;
}
if (_dragGesture == null)
return;
var rect = _dragGesture.GetHidePosition ();
menu.Layout (new Xamarin.Forms.Rectangle (
rect.left / metrics.Density,
rect.top / metrics.Density,
(rect.right - rect.left) / metrics.Density,
(rect.bottom - rect.top) / metrics.Density));
_popMenuOverlayRenderer.UpdateLayout ();
_popMenuOverlayRenderer.ViewGroup.Visibility = ViewStates.Visible;
rootView.Layout ((int)rect.left, (int)rect.top, (int)rect.right, (int)rect.bottom);
_pageRenderer.ViewGroup.AddView (rootView);
_pageRenderer.ViewGroup.BringChildToFront (rootView);
_dragGesture.NeedShowBackgroundView = (open, alpha) => {
if (open)
ShowBackgroundOverlay (alpha);
else
HideBackgroundOverlay ();
};
}
}
public void Update(ViewCell cell)
{
Performance.Start();
var renderer = GetChildAt(0) as IVisualElementRenderer;
var viewHandlerType = Registrar.Registered.GetHandlerType(cell.View.GetType()) ?? typeof(Platform.DefaultRenderer);
if (renderer != null && renderer.GetType() == viewHandlerType)
{
Performance.Start("Reuse");
_viewCell = cell;
cell.View.DisableLayout = true;
foreach (VisualElement c in cell.View.Descendants())
c.DisableLayout = true;
Performance.Start("Reuse.SetElement");
renderer.SetElement(cell.View);
Performance.Stop("Reuse.SetElement");
Platform.SetRenderer(cell.View, _view);
cell.View.DisableLayout = false;
foreach (VisualElement c in cell.View.Descendants())
c.DisableLayout = false;
var viewAsLayout = cell.View as Layout;
if (viewAsLayout != null)
viewAsLayout.ForceLayout();
Invalidate();
Performance.Stop("Reuse");
Performance.Stop();
return;
}
RemoveView(_view.ViewGroup);
Platform.SetRenderer(_viewCell.View, null);
_viewCell.View.IsPlatformEnabled = false;
_view.ViewGroup.Dispose();
_viewCell = cell;
_view = Platform.CreateRenderer(_viewCell.View);
Platform.SetRenderer(_viewCell.View, _view);
AddView(_view.ViewGroup);
UpdateIsEnabled();
Performance.Stop();
}
public AutomationPropertiesProvider(IVisualElementRenderer renderer)
{
_renderer = renderer;
_renderer.ElementPropertyChanged += OnElementPropertyChanged;
_renderer.ElementChanged += OnElementChanged;
}
public PopupPlatformRenderer(IVisualElementRenderer renderer)
{
_renderer = renderer;
}
public static void SetRenderer(BindableObject bindable, IVisualElementRenderer value)
{
bindable.SetValue(Platform.RendererProperty, value);
}
protected override void OnLayout(bool changed, int l, int t, int r, int b)
{
FormsViewPager pager = _viewPager;
Context context = Context;
var width = r - l;
var height = b - t;
if (IsBottomTabPlacement)
{
if (width <= 0 || height <= 0)
{
return;
}
_relativeLayout.Measure(
MeasureSpec.MakeMeasureSpec(width, MeasureSpecMode.Exactly),
MeasureSpec.MakeMeasureSpec(height, MeasureSpecMode.Exactly));
pager.Measure(MeasureSpecFactory.MakeMeasureSpec(width, MeasureSpecMode.AtMost), MeasureSpecFactory.MakeMeasureSpec(height, MeasureSpecMode.AtMost));
if (width > 0 && height > 0)
{
PageController.ContainerArea = new Rectangle(0, 0, context.FromPixels(width), context.FromPixels(height - _bottomNavigationView.Height));
pager.Layout(0, 0, width, b);
// We need to measure again to ensure that the tabs show up
_relativeLayout.Measure(
MeasureSpec.MakeMeasureSpec(width, MeasureSpecMode.Exactly),
MeasureSpec.MakeMeasureSpec(height, MeasureSpecMode.Exactly));
_relativeLayout.Layout(0, 0, _relativeLayout.MeasuredWidth, _relativeLayout.MeasuredHeight);
}
}
else
{
TabLayout tabs = _tabLayout;
tabs.Measure(MeasureSpecFactory.MakeMeasureSpec(width, MeasureSpecMode.Exactly), MeasureSpecFactory.MakeMeasureSpec(height, MeasureSpecMode.AtMost));
var tabsHeight = 0;
if (tabs.Visibility != ViewStates.Gone)
{
//MinimumHeight is only available on API 16+
if ((int)Build.VERSION.SdkInt >= 16)
{
tabsHeight = Math.Min(height, Math.Max(tabs.MeasuredHeight, tabs.MinimumHeight));
}
else
{
tabsHeight = Math.Min(height, tabs.MeasuredHeight);
}
}
pager.Measure(MeasureSpecFactory.MakeMeasureSpec(width, MeasureSpecMode.AtMost), MeasureSpecFactory.MakeMeasureSpec(height, MeasureSpecMode.AtMost));
if (width > 0 && height > 0)
{
PageController.ContainerArea = new Rectangle(0, context.FromPixels(tabsHeight), context.FromPixels(width), context.FromPixels(height - tabsHeight));
for (var i = 0; i < PageController.InternalChildren.Count; i++)
{
var child = PageController.InternalChildren[i] as VisualElement;
if (child == null)
{
continue;
}
IVisualElementRenderer renderer = Android.Platform.GetRenderer(child);
var navigationRenderer = renderer as NavigationPageRenderer;
if (navigationRenderer != null)
{
navigationRenderer.ContainerPadding = tabsHeight;
}
}
pager.Layout(0, 0, width, b);
// We need to measure again to ensure that the tabs show up
tabs.Measure(MeasureSpecFactory.MakeMeasureSpec(width, MeasureSpecMode.Exactly), MeasureSpecFactory.MakeMeasureSpec(tabsHeight, MeasureSpecMode.Exactly));
tabs.Layout(0, 0, width, tabsHeight);
UpdateTabBarTranslation(pager.CurrentItem, 0);
}
}
base.OnLayout(changed, l, t, r, b);
}
public static void SetRenderer(this VisualElement self, IVisualElementRenderer renderer)
{
Platform.SetRenderer(self, renderer);
}
protected override void Dispose(bool disposing)
{
if (disposing)
_modal = null;
base.Dispose(disposing);
}
public VisualElementTracker(IVisualElementRenderer renderer) : this(renderer, true)
{
}
