From b8f00ce930a41ddb12342005a76c27fb01fb2891 Mon Sep 17 00:00:00 2001
From: Alex Corrado <alexc@xamarin.com>
Date: Fri, 30 Mar 2018 16:00:21 -0400
Subject: [PATCH 1/5] Add ICommandableElement interface, implement on
 everything that exposes a Command property

---
 Xamarin.Forms.Core/Button.cs                 |  2 +-
 Xamarin.Forms.Core/Cells/TextCell.cs         |  3 ++-
 Xamarin.Forms.Core/ClickGestureRecognizer.cs |  3 ++-
 Xamarin.Forms.Core/Entry.cs                  | 14 +++++++++++++-
 Xamarin.Forms.Core/ICommandableElement.cs    | 12 ++++++++++++
 Xamarin.Forms.Core/MenuItem.cs               |  3 ++-
 Xamarin.Forms.Core/SearchBar.cs              | 14 +++++++++++++-
 Xamarin.Forms.Core/TapGestureRecognizer.cs   |  3 ++-
 8 files changed, 47 insertions(+), 7 deletions(-)
 create mode 100644 Xamarin.Forms.Core/ICommandableElement.cs

diff --git a/Xamarin.Forms.Core/Button.cs b/Xamarin.Forms.Core/Button.cs
index cecc807a9d0..1f4804e1f80 100644
--- a/Xamarin.Forms.Core/Button.cs
+++ b/Xamarin.Forms.Core/Button.cs
@@ -8,7 +8,7 @@
 namespace Xamarin.Forms
 {
 	[RenderWith(typeof(_ButtonRenderer))]
-	public class Button : View, IFontElement, ITextElement, IBorderElement, IButtonController, IElementConfiguration<Button>, IPaddingElement
+	public class Button : View, IFontElement, ITextElement, IBorderElement, IButtonController, IElementConfiguration<Button>, IPaddingElement, ICommandableElement
 	{
 		const double DefaultSpacing = 10;
 		const int DefaultBorderRadius = 5;
diff --git a/Xamarin.Forms.Core/Cells/TextCell.cs b/Xamarin.Forms.Core/Cells/TextCell.cs
index c3a60a8a0bb..df717c1fdda 100644
--- a/Xamarin.Forms.Core/Cells/TextCell.cs
+++ b/Xamarin.Forms.Core/Cells/TextCell.cs
@@ -1,9 +1,10 @@
 using System;
 using System.Windows.Input;
+using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms
 {
-	public class TextCell : Cell
+	public class TextCell : Cell, ICommandableElement
 	{
 		public static readonly BindableProperty CommandProperty = BindableProperty.Create("Command", typeof(ICommand), typeof(TextCell), default(ICommand),
 			propertyChanging: (bindable, oldvalue, newvalue) =>
diff --git a/Xamarin.Forms.Core/ClickGestureRecognizer.cs b/Xamarin.Forms.Core/ClickGestureRecognizer.cs
index 628aa537493..6f4a0eab9e7 100644
--- a/Xamarin.Forms.Core/ClickGestureRecognizer.cs
+++ b/Xamarin.Forms.Core/ClickGestureRecognizer.cs
@@ -1,6 +1,7 @@
 using System;
 using System.ComponentModel;
 using System.Windows.Input;
+using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms
 {
@@ -11,7 +12,7 @@ public enum ButtonsMask
 		Secondary = 1 << 1
 	}
 
-	public sealed class ClickGestureRecognizer : GestureRecognizer
+	public sealed class ClickGestureRecognizer : GestureRecognizer, ICommandableElement
 	{
 		public static readonly BindableProperty CommandProperty = BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(ClickGestureRecognizer), null);
 
diff --git a/Xamarin.Forms.Core/Entry.cs b/Xamarin.Forms.Core/Entry.cs
index ecf499ed8e4..a8c9238148d 100644
--- a/Xamarin.Forms.Core/Entry.cs
+++ b/Xamarin.Forms.Core/Entry.cs
@@ -7,7 +7,7 @@
 namespace Xamarin.Forms
 {
 	[RenderWith(typeof(_EntryRenderer))]
-	public class Entry : InputView, IFontElement, ITextElement, ITextAlignmentElement, IEntryController, IElementConfiguration<Entry>
+	public class Entry : InputView, IFontElement, ITextElement, ITextAlignmentElement, IEntryController, IElementConfiguration<Entry>, ICommandableElement
 	{
 		public static readonly BindableProperty ReturnTypeProperty = BindableProperty.Create(nameof(ReturnType), typeof(ReturnType), typeof(Entry), ReturnType.Default);
 
@@ -137,6 +137,18 @@ public object ReturnCommandParameter
 			set => SetValue(ReturnCommandParameterProperty, value);
 		}
 
+		ICommand ICommandableElement.Command
+		{
+			get => ReturnCommand;
+			set => ReturnCommand = value;
+		}
+
+		object ICommandableElement.CommandParameter
+		{
+			get => ReturnCommandParameter;
+			set => ReturnCommandParameter = value;
+		}
+
 		double IFontElement.FontSizeDefaultValueCreator() =>
 			Device.GetNamedSize(NamedSize.Default, (Entry)this);
 
diff --git a/Xamarin.Forms.Core/ICommandableElement.cs b/Xamarin.Forms.Core/ICommandableElement.cs
new file mode 100644
index 00000000000..b0b953af973
--- /dev/null
+++ b/Xamarin.Forms.Core/ICommandableElement.cs
@@ -0,0 +1,12 @@
+using System.Windows.Input;
+using System.ComponentModel;
+
+namespace Xamarin.Forms.Internals
+{
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public interface ICommandableElement
+	{
+		ICommand Command { get; set; }
+		object CommandParameter { get; set; }
+	}
+}
diff --git a/Xamarin.Forms.Core/MenuItem.cs b/Xamarin.Forms.Core/MenuItem.cs
index 6e9daf43ca3..80262379f17 100644
--- a/Xamarin.Forms.Core/MenuItem.cs
+++ b/Xamarin.Forms.Core/MenuItem.cs
@@ -2,11 +2,12 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Windows.Input;
+using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms
 {
 
-	public class MenuItem : BaseMenuItem, IMenuItemController
+	public class MenuItem : BaseMenuItem, IMenuItemController, ICommandableElement
 	{
 		public static readonly BindableProperty AcceleratorProperty = BindableProperty.CreateAttached(nameof(Accelerator), typeof(Accelerator), typeof(MenuItem), null);
 
diff --git a/Xamarin.Forms.Core/SearchBar.cs b/Xamarin.Forms.Core/SearchBar.cs
index c2cfa6a2fec..5b2219960cc 100644
--- a/Xamarin.Forms.Core/SearchBar.cs
+++ b/Xamarin.Forms.Core/SearchBar.cs
@@ -7,7 +7,7 @@
 namespace Xamarin.Forms
 {
 	[RenderWith(typeof(_SearchBarRenderer))]
-	public class SearchBar : View, IFontElement, ITextElement, ITextAlignmentElement, ISearchBarController, IElementConfiguration<SearchBar>
+	public class SearchBar : View, IFontElement, ITextElement, ITextAlignmentElement, ISearchBarController, IElementConfiguration<SearchBar>, ICommandableElement
 	{
 		public static readonly BindableProperty SearchCommandProperty = BindableProperty.Create("SearchCommand", typeof(ICommand), typeof(SearchBar), null, propertyChanged: OnCommandChanged);
 
@@ -112,6 +112,18 @@ public double FontSize
 			set { SetValue(FontSizeProperty, value); }
 		}
 
+		ICommand ICommandableElement.Command
+		{
+			get => SearchCommand;
+			set => SearchCommand = value;
+		}
+
+		object ICommandableElement.CommandParameter
+		{
+			get => SearchCommandParameter;
+			set => SearchCommandParameter = value;
+		}
+
 		void IFontElement.OnFontFamilyChanged(string oldValue, string newValue)
 		{
 		}
diff --git a/Xamarin.Forms.Core/TapGestureRecognizer.cs b/Xamarin.Forms.Core/TapGestureRecognizer.cs
index 74100967be4..c9a505f969d 100644
--- a/Xamarin.Forms.Core/TapGestureRecognizer.cs
+++ b/Xamarin.Forms.Core/TapGestureRecognizer.cs
@@ -1,10 +1,11 @@
 using System;
 using System.ComponentModel;
 using System.Windows.Input;
+using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms
 {
-	public sealed class TapGestureRecognizer : GestureRecognizer
+	public sealed class TapGestureRecognizer : GestureRecognizer, ICommandableElement
 	{
 		public static readonly BindableProperty CommandProperty = BindableProperty.Create("Command", typeof(ICommand), typeof(TapGestureRecognizer), null);
 

From 06e38c9ba98363322f93615f2ead91bd80219555 Mon Sep 17 00:00:00 2001
From: Alex Corrado <alexc@xamarin.com>
Date: Tue, 24 Apr 2018 13:52:32 -0400
Subject: [PATCH 2/5] [Core] Add initial Segues APIs

---
 Xamarin.Forms.Core/Application.cs             |  36 ++-
 Xamarin.Forms.Core/BindableObject.cs          |  10 +
 Xamarin.Forms.Core/ICommandableElement.cs     |   1 +
 Xamarin.Forms.Core/INavigation.cs             |   4 +
 .../Internals/SegueRequestedEventArgs.cs      |  19 ++
 Xamarin.Forms.Core/NavigationPage.cs          |  75 +++++-
 Xamarin.Forms.Core/NavigationProxy.cs         | 111 ++++----
 Xamarin.Forms.Core/Segues/ISegueExecution.cs  |  12 +
 Xamarin.Forms.Core/Segues/NavigationAction.cs |  80 ++++++
 Xamarin.Forms.Core/Segues/Segue.cs            | 248 ++++++++++++++++++
 .../Segues/SegueBeforeExecuteEventArgs.cs     |  13 +
 Xamarin.Forms.Core/Segues/SegueExtensions.cs  |  81 ++++++
 Xamarin.Forms.Core/Segues/SegueTarget.cs      | 114 ++++++++
 Xamarin.Forms.Core/Segues/ValueSegue.cs       |  63 +++++
 Xamarin.Forms.Core/Xamarin.Forms.Core.csproj  |   3 +
 .../MarkupExtensions/SegueExtension.cs        |  59 +++++
 16 files changed, 864 insertions(+), 65 deletions(-)
 create mode 100644 Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs
 create mode 100644 Xamarin.Forms.Core/Segues/ISegueExecution.cs
 create mode 100644 Xamarin.Forms.Core/Segues/NavigationAction.cs
 create mode 100644 Xamarin.Forms.Core/Segues/Segue.cs
 create mode 100644 Xamarin.Forms.Core/Segues/SegueBeforeExecuteEventArgs.cs
 create mode 100644 Xamarin.Forms.Core/Segues/SegueExtensions.cs
 create mode 100644 Xamarin.Forms.Core/Segues/SegueTarget.cs
 create mode 100644 Xamarin.Forms.Core/Segues/ValueSegue.cs
 create mode 100644 Xamarin.Forms.Xaml/MarkupExtensions/SegueExtension.cs

diff --git a/Xamarin.Forms.Core/Application.cs b/Xamarin.Forms.Core/Application.cs
index f2cdf23b71b..a44f5284014 100644
--- a/Xamarin.Forms.Core/Application.cs
+++ b/Xamarin.Forms.Core/Application.cs
@@ -369,7 +369,21 @@ public NavigationImpl(Application owner)
 				_owner = owner;
 			}
 
-			protected override async Task<Page> OnPopModal(bool animated)
+			protected internal override Task OnSegue(ValueSegue segue, SegueTarget target)
+			{
+				switch (segue.Action)
+				{
+					case NavigationAction.PopModal:
+					case NavigationAction.Pop when this.ShouldPopModal():
+						return OnPopModal(segue);
+
+					case NavigationAction.Modal:
+						return OnPushModal(segue, target);
+				}
+				return base.OnSegue(segue, target);
+			}
+
+			async Task<Page> OnPopModal(ValueSegue segue)
 			{
 				Page modal = ModalStack[ModalStack.Count - 1];
 				if (_owner.OnModalPopping(modal))
@@ -377,14 +391,26 @@ protected override async Task<Page> OnPopModal(bool animated)
 					_owner.OnPopCanceled();
 					return null;
 				}
-				Page result = await base.OnPopModal(animated);
+				Page result = await ((Task<Page>)base.OnSegue(segue, null));
 				result.Parent = null;
 				_owner.OnModalPopped(result);
 				return result;
 			}
 
-			protected override async Task OnPushModal(Page modal, bool animated)
+			async Task OnPushModal(ValueSegue segue, SegueTarget target)
 			{
+				var modal = target.TryCreatePage();
+				if (modal == null)
+				{
+					await base.OnSegue(segue, target);
+					return;
+				}
+
+				// IMPORTANT! If the target was a template, create a new SegueTarget from
+				//  the instantiated page.
+				if (target.IsTemplate)
+					target = (SegueTarget)modal;
+
 				_owner.OnModalPushing(modal);
 
 				modal.Parent = _owner;
@@ -392,11 +418,11 @@ protected override async Task OnPushModal(Page modal, bool animated)
 				if (modal.NavigationProxy.ModalStack.Count == 0)
 				{
 					modal.NavigationProxy.Inner = this;
-					await base.OnPushModal(modal, animated);
+					await base.OnSegue(segue, target);
 				}
 				else
 				{
-					await base.OnPushModal(modal, animated);
+					await base.OnSegue(segue, target);
 					modal.NavigationProxy.Inner = this;
 				}
 
diff --git a/Xamarin.Forms.Core/BindableObject.cs b/Xamarin.Forms.Core/BindableObject.cs
index 21076a59e86..c44aa478c31 100644
--- a/Xamarin.Forms.Core/BindableObject.cs
+++ b/Xamarin.Forms.Core/BindableObject.cs
@@ -172,6 +172,16 @@ internal bool GetIsBound(BindableProperty targetProperty)
 			return bpcontext != null && bpcontext.Binding != null;
 		}
 
+		internal bool GetIsManuallySet(BindableProperty targetProperty)
+		{
+			if (targetProperty == null)
+				throw new ArgumentNullException(nameof(targetProperty));
+
+			var bpcontext = GetContext(targetProperty);
+			return bpcontext != null
+				&& (bpcontext.Attributes & BindableContextAttributes.IsManuallySet) == BindableContextAttributes.IsManuallySet;
+		}
+
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public object[] GetValues(BindableProperty property0, BindableProperty property1)
 		{
diff --git a/Xamarin.Forms.Core/ICommandableElement.cs b/Xamarin.Forms.Core/ICommandableElement.cs
index b0b953af973..f04c51aacf4 100644
--- a/Xamarin.Forms.Core/ICommandableElement.cs
+++ b/Xamarin.Forms.Core/ICommandableElement.cs
@@ -3,6 +3,7 @@
 
 namespace Xamarin.Forms.Internals
 {
+	// implementing classes must be castable to Element
 	[EditorBrowsable(EditorBrowsableState.Never)]
 	public interface ICommandableElement
 	{
diff --git a/Xamarin.Forms.Core/INavigation.cs b/Xamarin.Forms.Core/INavigation.cs
index 6ae5959ded7..a2081ff426c 100644
--- a/Xamarin.Forms.Core/INavigation.cs
+++ b/Xamarin.Forms.Core/INavigation.cs
@@ -23,6 +23,10 @@ public interface INavigation
 		Task PushModalAsync(Page page);
 		Task PushModalAsync(Page page, bool animated);
 
+		Task ShowAsync(Page page);
+		Task ShowAsync(Page page, bool animated);
+		Task SegueAsync(Segue segue, SegueTarget target);
+
 		void RemovePage(Page page);
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs b/Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs
new file mode 100644
index 00000000000..a09d4e33ff7
--- /dev/null
+++ b/Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs
@@ -0,0 +1,19 @@
+using System.ComponentModel;
+using System.Threading.Tasks;
+
+namespace Xamarin.Forms.Internals
+{
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public class SegueRequestedEventArgs
+	{
+		public ValueSegue Segue { get; }
+		public SegueTarget Target { get; }
+		public Task Task { get; set; }
+
+		internal SegueRequestedEventArgs(ValueSegue segue, SegueTarget target)
+		{
+			Segue = segue;
+			Target = target;
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core/NavigationPage.cs b/Xamarin.Forms.Core/NavigationPage.cs
index b6572cee034..f66e21a8fac 100644
--- a/Xamarin.Forms.Core/NavigationPage.cs
+++ b/Xamarin.Forms.Core/NavigationPage.cs
@@ -200,6 +200,24 @@ public async Task PushAsync(Page page, bool animated)
 
 		public event EventHandler<NavigationEventArgs> Pushed;
 
+		async Task SegueAsync(ValueSegue segue, SegueTarget target)
+		{
+			if (CurrentNavigationTask != null && !CurrentNavigationTask.IsCompleted)
+			{
+				var tcs = new TaskCompletionSource<bool>();
+				Task oldTask = CurrentNavigationTask;
+				CurrentNavigationTask = tcs.Task;
+				await oldTask;
+
+				await SegueAsyncInner(segue, target);
+				tcs.SetResult(true);
+				return;
+			}
+
+			CurrentNavigationTask = SegueAsyncInner(segue, target);
+			await CurrentNavigationTask;
+		}
+
 		public static void SetBackButtonTitle(BindableObject page, string value)
 		{
 			page.SetValue(BackButtonTitleProperty, value);
@@ -297,6 +315,9 @@ async Task<Page> INavigationPageController.RemoveAsyncInner(Page page, bool anim
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public event EventHandler<NavigationRequestedEventArgs> RemovePageRequested;
 
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public event EventHandler<SegueRequestedEventArgs> SegueRequested;
+
 		void InsertPageBefore(Page page, Page before)
 		{
 			if (page == null)
@@ -381,6 +402,19 @@ void PushPage(Page page)
 			CurrentPage = page;
 		}
 
+		async Task SegueAsyncInner(ValueSegue segue, SegueTarget target)
+		{
+			EventHandler<SegueRequestedEventArgs> requestSegue = SegueRequested;
+			if (requestSegue != null)
+			{
+				var args = new SegueRequestedEventArgs(segue, target);
+				requestSegue(this, args);
+
+				if (args.Task != null)
+					await args.Task;
+			}
+		}
+
 		void RemovePage(Page page)
 		{
 			if (page == null)
@@ -437,19 +471,36 @@ protected override void OnInsertPageBefore(Page page, Page before)
 				Owner.InsertPageBefore(page, before);
 			}
 
-			protected override Task<Page> OnPopAsync(bool animated)
-			{
-				return Owner.PopAsync(animated);
-			}
-
-			protected override Task OnPopToRootAsync(bool animated)
-			{
-				return Owner.PopToRootAsync(animated);
-			}
-
-			protected override Task OnPushAsync(Page root, bool animated)
+			protected internal override Task OnSegue(ValueSegue seg, SegueTarget target)
 			{
-				return Owner.PushAsync(root, animated);
+				var action = seg.Action;
+				switch (action)
+				{
+					case NavigationAction.Modal:
+					case NavigationAction.MainPage:
+					case NavigationAction.PopModal:
+					case NavigationAction.Pop when this.ShouldPopModal():
+						return base.OnSegue(seg, target);
+				}
+
+				Page page = null;
+				if (seg.Segue != null || (target != null && (page = target.TryCreatePage()) == null))
+					return Owner.SegueAsync(seg, target);
+
+				switch (action)
+				{
+					case NavigationAction.Show:
+					case NavigationAction.Push:
+						return Owner.PushAsync(page, seg.IsAnimated);
+
+					case NavigationAction.Pop:
+					case NavigationAction.PopPushed:
+						return Owner.PopAsync(seg.IsAnimated);
+					case NavigationAction.PopToRoot:
+						return Owner.PopToRootAsync(seg.IsAnimated);
+				}
+
+				throw new NotSupportedException(action.ToString());
 			}
 
 			protected override void OnRemovePage(Page page)
diff --git a/Xamarin.Forms.Core/NavigationProxy.cs b/Xamarin.Forms.Core/NavigationProxy.cs
index 9fc37875a31..f74f44e490d 100644
--- a/Xamarin.Forms.Core/NavigationProxy.cs
+++ b/Xamarin.Forms.Core/NavigationProxy.cs
@@ -71,32 +71,32 @@ public IReadOnlyList<Page> NavigationStack
 
 		public Task<Page> PopAsync()
 		{
-			return OnPopAsync(true);
+			return PopAsync(true);
 		}
 
 		public Task<Page> PopAsync(bool animated)
 		{
-			return OnPopAsync(animated);
+			return (Task<Page>)OnSegue(new ValueSegue(NavigationAction.PopPushed, animated), null);
 		}
 
 		public Task<Page> PopModalAsync()
 		{
-			return OnPopModal(true);
+			return PopModalAsync(true);
 		}
 
 		public Task<Page> PopModalAsync(bool animated)
 		{
-			return OnPopModal(animated);
+			return (Task<Page>)OnSegue(new ValueSegue(NavigationAction.PopModal, animated), null);
 		}
 
 		public Task PopToRootAsync()
 		{
-			return OnPopToRootAsync(true);
+			return PopToRootAsync(true);
 		}
 
 		public Task PopToRootAsync(bool animated)
 		{
-			return OnPopToRootAsync(animated);
+			return OnSegue(new ValueSegue(NavigationAction.PopToRoot, animated), null);
 		}
 
 		public Task PushAsync(Page root)
@@ -108,7 +108,7 @@ public Task PushAsync(Page root, bool animated)
 		{
 			if (root.RealParent != null)
 				throw new InvalidOperationException("Page must not already have a parent.");
-			return OnPushAsync(root, animated);
+			return OnSegue(new ValueSegue(NavigationAction.Push, animated), (SegueTarget)root);
 		}
 
 		public Task PushModalAsync(Page modal)
@@ -120,7 +120,24 @@ public Task PushModalAsync(Page modal, bool animated)
 		{
 			if (modal.RealParent != null)
 				throw new InvalidOperationException("Page must not already have a parent.");
-			return OnPushModal(modal, animated);
+			return OnSegue(new ValueSegue(NavigationAction.Modal, animated), (SegueTarget)modal);
+		}
+
+		public Task ShowAsync(Page page)
+		{
+			return ShowAsync(page, true);
+		}
+
+		public Task ShowAsync(Page page, bool animated)
+		{
+			if (page.RealParent != null)
+				throw new InvalidOperationException("Page must not already have a parent.");
+			return OnSegue(new ValueSegue(NavigationAction.Show, animated), (SegueTarget)page);
+		}
+
+		public Task SegueAsync(Segue segue, SegueTarget target)
+		{
+			return OnSegue(segue, target);
 		}
 
 		public void RemovePage(Page page)
@@ -156,51 +173,49 @@ protected virtual void OnInsertPageBefore(Page page, Page before)
 			}
 		}
 
-		protected virtual Task<Page> OnPopAsync(bool animated)
-		{
-			INavigation inner = Inner;
-			return inner == null ? Task.FromResult(Pop()) : inner.PopAsync(animated);
-		}
-
-		protected virtual Task<Page> OnPopModal(bool animated)
-		{
-			INavigation innerNav = Inner;
-			return innerNav == null ? Task.FromResult(PopModal()) : innerNav.PopModalAsync(animated);
-		}
-
-		protected virtual Task OnPopToRootAsync(bool animated)
-		{
-			INavigation currentInner = Inner;
-			if (currentInner == null)
-			{
-				Page root = _pushStack.Value.Last();
-				_pushStack.Value.Clear();
-				_pushStack.Value.Add(root);
-				return Task.FromResult(root);
-			}
-			return currentInner.PopToRootAsync(animated);
-		}
-
-		protected virtual Task OnPushAsync(Page page, bool animated)
+		protected internal virtual Task OnSegue(ValueSegue segue, SegueTarget target)
 		{
 			INavigation currentInner = Inner;
 			if (currentInner == null)
 			{
-				_pushStack.Value.Add(page);
-				return Task.FromResult(page);
-			}
-			return currentInner.PushAsync(page, animated);
-		}
-
-		protected virtual Task OnPushModal(Page modal, bool animated)
-		{
-			INavigation currentInner = Inner;
-			if (currentInner == null)
-			{
-				_modalStack.Value.Add(modal);
-				return Task.FromResult<object>(null);
+				Page page = null;
+				if (segue.Action.RequiresTarget())
+				{
+					if (target == null)
+						throw new ArgumentNullException(nameof(target));
+					page = (Page)target.TryCreatePage();
+					if (page == null)
+						throw new InvalidOperationException($"Navigation must be rooted for non-Page target");
+				}
+				switch (segue.Action)
+				{
+					case NavigationAction.Show:
+						throw new InvalidOperationException($"Navigation must be rooted to use {nameof(NavigationAction.Show)}");
+
+					case NavigationAction.Push:
+						_pushStack.Value.Add(page);
+						return Task.CompletedTask;
+					case NavigationAction.Modal:
+						_modalStack.Value.Add(page);
+						return Task.CompletedTask;
+
+					// It's important these Pop* cases (except PopToRoot) return Task<Page>
+					case NavigationAction.Pop:
+						return Task.FromResult(this.ShouldPopModal() ? PopModal() : Pop());
+					case NavigationAction.PopPushed:
+						return Task.FromResult(Pop());
+					case NavigationAction.PopModal:
+						return Task.FromResult(PopModal());
+
+					case NavigationAction.PopToRoot:
+						Page root = _pushStack.Value.Last();
+						_pushStack.Value.Clear();
+						_pushStack.Value.Add(root);
+						return Task.CompletedTask;
+				}
+				return this.NavigateAsync(segue.Action, page, segue.IsAnimated);
 			}
-			return currentInner.PushModalAsync(modal, animated);
+			return currentInner.SegueAsync(segue, target);
 		}
 
 		protected virtual void OnRemovePage(Page page)
diff --git a/Xamarin.Forms.Core/Segues/ISegueExecution.cs b/Xamarin.Forms.Core/Segues/ISegueExecution.cs
new file mode 100644
index 00000000000..57097e7e85f
--- /dev/null
+++ b/Xamarin.Forms.Core/Segues/ISegueExecution.cs
@@ -0,0 +1,12 @@
+using System;
+using System.ComponentModel;
+using System.Threading.Tasks;
+
+namespace Xamarin.Forms.Internals
+{
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public interface ISegueExecution
+	{
+		Task<bool> OnBeforeExecute(SegueTarget target);
+	}
+}
diff --git a/Xamarin.Forms.Core/Segues/NavigationAction.cs b/Xamarin.Forms.Core/Segues/NavigationAction.cs
new file mode 100644
index 00000000000..6a05eebde93
--- /dev/null
+++ b/Xamarin.Forms.Core/Segues/NavigationAction.cs
@@ -0,0 +1,80 @@
+using System;
+
+using Xamarin.Forms;
+
+namespace Xamarin.Forms
+{
+	[TypeConverter(typeof(NavigationActionConverter))]
+	public enum NavigationAction
+	{
+		/// <summary>
+		/// Corresponds to calling <see cref="INavigation.ShowAsync"/>
+		/// </summary>
+		Show = 0,
+
+		/// <summary>
+		/// Corresponds to calling <see cref="INavigation.PushAsync"/>.
+		/// </summary>
+		Push = 1,
+
+		/// <summary>
+		/// Corresponds to calling <see cref="INavigation.PushModalAsync"/>.
+		/// </summary>
+		Modal = 2,
+
+		/// <summary>
+		/// Corresponds to setting <see cref="Application.MainPage"/>.
+		/// </summary>
+		MainPage = 3,
+
+		/// <summary>
+		/// Corresponds to calling either <see cref="INavigation.PopAsync"/> or
+		///  <see cref="INavigation.PopModalAsync"/>, as appropriate.
+		/// </summary>
+		Pop = 4,
+
+		/// <summary>
+		/// Corresponds to calling <see cref="INavigation.PopAsync"/>.
+		/// </summary>
+		PopPushed = Pop | Push,
+
+		/// <summary>
+		/// Corresponds to calling <see cref="INavigation.PopModalAsync"/>.
+		/// </summary>
+		PopModal = Pop | Modal,
+
+		/// <summary>
+		/// Corresponds to calling <see cref="INavigation.PopToRootAsync"/>.
+		/// </summary>
+		PopToRoot = Pop | MainPage,
+	}
+
+	public class NavigationActionConverter : TypeConverter
+	{
+		public static bool TryParse(string value, out NavigationAction action)
+		{
+			switch (value.ToLowerInvariant()) {
+			case "show"     : action = NavigationAction.Show; return true;
+			case "push"     : action = NavigationAction.Push; return true;
+			case "modal"    : action = NavigationAction.Modal; return true;
+			case "mainpage" : action = NavigationAction.MainPage; return true;
+			case "pop"      : action = NavigationAction.Pop; return true;
+			case "poppushed": action = NavigationAction.PopPushed; return true;
+			case "popmodal" : action = NavigationAction.PopModal; return true;
+			case "poptoroot": action = NavigationAction.PopToRoot; return true;
+			}
+			action = default(NavigationAction);
+			return false;
+		}
+
+		public static NavigationAction Parse(string value)
+		{
+			NavigationAction result;
+			if (!TryParse(value, out result))
+				throw new ArgumentException();
+			return result;
+		}
+
+		public override object ConvertFromInvariantString(string value) => Parse(value);
+	}
+}
diff --git a/Xamarin.Forms.Core/Segues/Segue.cs b/Xamarin.Forms.Core/Segues/Segue.cs
new file mode 100644
index 00000000000..3ef7c46f440
--- /dev/null
+++ b/Xamarin.Forms.Core/Segues/Segue.cs
@@ -0,0 +1,248 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.ComponentModel;
+using System.Windows.Input;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using Xamarin.Forms.Internals;
+
+namespace Xamarin.Forms
+{
+	/// <summary>
+	/// A navigational transition from one <see cref="Page"/> to another.
+	/// </summary>
+	public class Segue : BindableObject, ISegueExecution
+	{
+		public static readonly BindableProperty ActionProperty =
+			BindableProperty.Create(nameof(Action), typeof(NavigationAction), typeof(Segue), default(NavigationAction));
+
+		public static readonly BindableProperty IsAnimatedProperty =
+			BindableProperty.Create(nameof(IsAnimated), typeof(bool), typeof(Segue), defaultValue: true);
+
+		public static readonly BindableProperty IsEnabledProperty =
+			BindableProperty.Create(nameof(IsEnabled), typeof(bool), typeof(Segue), defaultValue: true, 
+				propertyChanged: (s, _, __) => ((Segue)s).OnCanExecuteChanged());
+
+		public static readonly BindableProperty SourceElementProperty =
+			BindableProperty.Create(nameof(SourceElement), typeof(Element), typeof(Segue));
+
+		public static readonly BindableProperty TargetProperty =
+			BindableProperty.CreateAttached("Target", typeof(SegueTarget), typeof(Segue), defaultValue: null,
+				propertyChanged: (obj, oldVal, newVal) => {
+					if ((oldVal == null || newVal == null) && obj is ICommandableElement e && e.Command is Segue.Command c)
+						c.OnCanExecuteChanged();
+				});
+
+		/// <summary>
+		/// Gets or sets the navigation action this <see cref="Segue"/> will perform when executed.
+		/// </summary>
+		public NavigationAction Action {
+			get => (NavigationAction)GetValue(ActionProperty);
+			set => SetValue(ActionProperty, value);
+		}
+
+		/// <summary>
+		/// Gets or sets a value indicating whether this <see cref="Segue"/> is animated when executed.
+		/// </summary>
+		/// <value><c>true</c> if animated; otherwise, <c>false</c>.</value>
+		public bool IsAnimated {
+			get => (bool)GetValue(IsAnimatedProperty);
+			set => SetValue(IsAnimatedProperty, value);
+		}
+
+		/// <summary>
+		/// Gets or sets a value indicating whether this <see cref="Segue"/> is enabled.
+		/// </summary>
+		/// <value><c>true</c> if enabled; otherwise, <c>false</c>.</value>
+		public bool IsEnabled {
+			get => (bool)GetValue(IsEnabledProperty);
+			set => SetValue(IsEnabledProperty, value);
+		}
+
+		/// <summary>
+		/// Gets the exact element that triggered this <see cref="Segue"/>, or <c>null</c>
+		///  if one wasn't provided.
+		/// </summary>
+		/// <remarks>
+		/// This property is set automatically when the <c>{Segue}</c> markup extension is used,
+		///  or by the <see cref="ICommand"/> returned by <see cref="ToCommand"/> when the
+		///  <c>source</c> parameter is provided. Setting or binding this property explicitly
+		///  disables that automatic behavior.
+		/// </remarks>
+		public Element SourceElement {
+			get => (Element)GetValue(SourceElementProperty);
+			set => SetValue(SourceElementProperty, value);
+		}
+
+		public event EventHandler<SegueBeforeExecuteEventArgs> BeforeExecute;
+
+		/// <summary>
+		/// Called before execution of this <see cref="Segue"/> to raise the <see cref="BeforeExecute"/> event.
+		/// </summary>
+		/// <remarks>
+		/// Execution of the segue is deferred until the returned <see cref="Task"/> completes with the result <c>true</c>.
+		///  If the result is <c>false</c>, execution of the segue is cancelled. You can use this method to display
+		///  an alert to the user to cancel the navigation, or to perform any asynchronous loading or clean up before
+		///  navigating to the next page.
+		/// </remarks>
+		/// <returns><c>true</c> to execute the segue, or <c>false</c> to cancel it.</returns>
+		/// <param name="target">The destination <see cref="SegueTarget"/> for this segue.</param>
+		protected virtual Task<bool> OnBeforeExecute(SegueTarget target)
+		{
+			var beforeExec = BeforeExecute;
+			if (beforeExec != null) {
+				var args = new SegueBeforeExecuteEventArgs(target);
+				beforeExec(this, args);
+				return Task.FromResult(!args.Cancelled);
+			}
+			return Task.FromResult(true);
+		}
+		Task<bool> ISegueExecution.OnBeforeExecute(SegueTarget target) => OnBeforeExecute(target);
+
+		public static SegueTarget GetTarget(BindableObject obj)
+		{
+			return (SegueTarget)obj.GetValue(TargetProperty);
+		}
+
+		public static void SetTarget(BindableObject obj, SegueTarget value)
+		{
+			obj.SetValue(TargetProperty, value);
+		}
+
+		#region ICommand adapters
+
+		event EventHandler CanExecuteChanged;
+
+		/// <summary>
+		/// Raises the <see cref="CanExecuteChanged"/> event.
+		/// </summary>
+		protected virtual void OnCanExecuteChanged()
+		{
+			CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+		}
+
+		/// <remarks>
+		/// If you override this method, be sure to call <see cref="OnCanExecuteChanged"/> as appropriate.
+		/// </remarks>
+		/// <param name="source">The source object that triggered this segue.</param>
+		/// <param name="parameter">Parameter passed to <see cref="ICommand.CanExecute(object)"/>.</param>
+		protected internal virtual bool CanExecuteCommand(Element source, object parameter)
+		{
+			return DefaultCanExecuteCommand(this, source);
+		}
+
+		internal static bool DefaultCanExecuteCommand(ValueSegue seg, Element source)
+		{
+			if (!seg.IsEnabled)
+				return false;
+
+			if (GetTarget(source) == null)
+				return !seg.Action.RequiresTarget();
+
+			return true;
+		}
+
+		/// <summary>
+		/// Called when an <see cref="ICommand"/> that was vended by <see cref="ToCommand"/> is executed.
+		/// </summary>
+		/// <param name="source">The source object that triggered this segue.</param>
+		/// <param name="parameter">Parameter passed to <see cref="ICommand.Execute(object)"/>.</param>
+		protected internal virtual Task ExecuteCommand(Element source, object parameter)
+		{
+			return DefaultExecuteCommand(this, source);
+		}
+
+		internal static Task DefaultExecuteCommand(ValueSegue seg, Element source)
+		{
+			if (!seg.IsEnabled)
+				throw new InvalidOperationException("IsEnabled is false");
+
+			var s = seg.Segue;
+			if (s != null)
+			{
+				// Set SourceElement property if it wasn't manually set or bound by the user
+				if (!(s.GetIsBound(SourceElementProperty) || s.GetIsManuallySet(SourceElementProperty)))
+					s.SetValueCore(SourceElementProperty, source);
+			}
+
+			var nav = FindVisualElement(source)?.Navigation;
+			if (nav == null)
+				throw new NotSupportedException("Source must be in the view hierarchy");
+
+ 			return nav.SegueAsync(seg, GetTarget(source));
+		}
+
+		static VisualElement FindVisualElement(Element elem)
+		{
+			while (elem != null) {
+				if (elem is VisualElement visElem)
+					return visElem;
+				elem = elem.Parent;
+			}
+			return null;
+		}
+
+		sealed class Command : ICommand
+		{
+			ValueSegue seg;
+			Element source;
+			EventHandler canExecuteChanged;
+
+			public event EventHandler CanExecuteChanged {
+				add {
+					if (canExecuteChanged == null && seg.Segue != null)
+						seg.Segue.CanExecuteChanged += Segue_CanExecuteChanged;
+					canExecuteChanged += value;
+				}
+				remove {
+					canExecuteChanged -= value;
+					if (canExecuteChanged == null && seg.Segue != null)
+						seg.Segue.CanExecuteChanged -= Segue_CanExecuteChanged;
+				}
+			}
+
+			public Command(ValueSegue seg, Element source)
+			{
+				this.seg = seg;
+				this.source = source;
+			}
+
+			public void OnCanExecuteChanged() => canExecuteChanged?.Invoke(this, EventArgs.Empty);
+			void Segue_CanExecuteChanged(object sender, EventArgs e) => OnCanExecuteChanged();
+
+			public bool CanExecute(object parameter) => seg.CanExecuteCommand(source, parameter);
+			public void Execute(object parameter) => seg.ExecuteCommand(source, parameter);
+		}
+
+		/// <summary>
+		/// Creates a new <see cref="ICommand"/> instance for triggering this segue
+		///  from the given source element.
+		/// </summary>
+		public ICommand ToCommand(Element source)
+		{
+			if (source == null)
+				throw new ArgumentNullException(nameof(source));
+			return new Command(this, source);
+		}
+
+		/// <summary>
+		/// Creates an <see cref="ICommand"/> to trigger the default <see cref="Segue"/>
+		///  from the given source <see cref="Element"/> with the given <see cref="NavigationAction"/>.
+		/// </summary>
+		/// <remarks>
+		/// Optimized equivalent to this:
+		/// <code>
+		///   new Segue { Action = action }.ToCommand(source)
+		/// </code>
+		/// </remarks>
+		public static ICommand CreateCommand(Element source, NavigationAction action, bool animated = true)
+		{
+			if (source == null)
+				throw new ArgumentNullException(nameof(source));
+			return new Command(new ValueSegue(action, animated), source);
+		}
+
+		#endregion
+	}
+}
diff --git a/Xamarin.Forms.Core/Segues/SegueBeforeExecuteEventArgs.cs b/Xamarin.Forms.Core/Segues/SegueBeforeExecuteEventArgs.cs
new file mode 100644
index 00000000000..3e4e518afdc
--- /dev/null
+++ b/Xamarin.Forms.Core/Segues/SegueBeforeExecuteEventArgs.cs
@@ -0,0 +1,13 @@
+using System;
+namespace Xamarin.Forms
+{
+	public class SegueBeforeExecuteEventArgs : EventArgs
+	{
+		public SegueTarget Target { get; }
+		public bool Cancelled { get; set; }
+		public SegueBeforeExecuteEventArgs(SegueTarget target)
+		{
+			Target = target;
+		}
+	}
+}
diff --git a/Xamarin.Forms.Core/Segues/SegueExtensions.cs b/Xamarin.Forms.Core/Segues/SegueExtensions.cs
new file mode 100644
index 00000000000..60a163dd769
--- /dev/null
+++ b/Xamarin.Forms.Core/Segues/SegueExtensions.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Xamarin.Forms.Internals;
+
+namespace Xamarin.Forms
+{
+	public static class SegueExtensions
+	{
+		/// <summary>
+		/// Performs the given <see cref="NavigationAction"/>.
+		/// </summary>
+		public static Task NavigateAsync(this INavigation nav, NavigationAction action, Page page, bool animated = true)
+		{
+			switch (action)
+			{
+				case NavigationAction.Show:
+					return nav.ShowAsync(page, animated);
+				case NavigationAction.Push:
+					return nav.PushAsync(page, animated);
+				case NavigationAction.Modal:
+					return nav.PushModalAsync(page, animated);
+				case NavigationAction.Pop:
+					return nav.ShouldPopModal() ? nav.PopModalAsync(animated) : nav.PopAsync(animated);
+				case NavigationAction.PopPushed:
+					return nav.PopAsync(animated);
+				case NavigationAction.PopModal:
+					return nav.PopModalAsync(animated);
+				case NavigationAction.PopToRoot:
+					return nav.PopToRootAsync(animated);
+				case NavigationAction.MainPage:
+					Application.Current.MainPage = page;
+					return Task.CompletedTask;
+			}
+			throw new ArgumentException("Unknown action", nameof(action));
+		}
+
+		public static Task NavigateAsync(this INavigation nav, NavigationAction action, SegueTarget target, bool animated = true)
+		{
+			return SegueAsync(nav, new ValueSegue(action, animated), target);
+		}
+
+		public static Task SegueAsync(this INavigation nav, Segue segue, Page page)
+		{
+			return nav.SegueAsync(segue, (SegueTarget)page);
+		}
+
+		internal static Task SegueAsync(this INavigation nav, ValueSegue seg, SegueTarget target)
+		{
+			// If possible, call direct to save us some hand waving and allocations..
+			if (nav is NavigationProxy proxy)
+				return proxy.OnSegue(seg, target);
+
+			// If this is a simple navigation, bypass the Segue machinery...
+			Page page = null;
+			if (seg.Segue == null && (target == null || (page = target.TryCreatePage()) != null))
+				return nav.NavigateAsync(seg.Action, page, seg.IsAnimated);
+
+			// This is potentially the most expensive..
+			return nav.SegueAsync(seg.GetOrCreateSegue(), target);
+		}
+
+		public static void SetSegue(this ICommandableElement trigger, Segue segue, SegueTarget target)
+			=> SetSegue(trigger, new ValueSegue(segue), target);
+
+		public static void SetSegue(this ICommandableElement trigger, NavigationAction action, SegueTarget target, bool animated = true)
+			=> SetSegue(trigger, new ValueSegue(action, animated), target);
+
+		static void SetSegue(ICommandableElement trigger, ValueSegue segue, SegueTarget target)
+		{
+			var elem = (Element)trigger;
+			Segue.SetTarget(elem, target);
+			trigger.Command = segue.ToCommand(elem);
+		}
+
+		public static bool RequiresTarget(this NavigationAction action) => !action.IsPopping();
+		internal static bool IsPopping(this NavigationAction action) => (action & NavigationAction.Pop) == NavigationAction.Pop;
+		internal static bool ShouldPopModal(this INavigation nav) => nav.ModalStack.Count > 0;
+	}
+}
diff --git a/Xamarin.Forms.Core/Segues/SegueTarget.cs b/Xamarin.Forms.Core/Segues/SegueTarget.cs
new file mode 100644
index 00000000000..13cd6c21b0f
--- /dev/null
+++ b/Xamarin.Forms.Core/Segues/SegueTarget.cs
@@ -0,0 +1,114 @@
+using System;
+using System.ComponentModel;
+
+namespace Xamarin.Forms
+{
+	public class SegueTarget
+	{
+		object target;
+
+		// This is set in the DataTemplate case below, or when Reject is called
+		WeakReference cachedValue;
+
+		// We don't know what type a DataTemplate will construct until we actually create it.
+		//  Here we attempt to avoid creating a lot of garbage when TryCreateValue is called
+		//  for types other than what our DataTemplate returns..
+		Type templatedType;
+
+		// Allow platforms to register their own SegueTarget subclasses that will
+		//  be used for implicit conversion from DataTemplate, etc..
+		protected static Func<object,SegueTarget> CreateFromObjectHandler { private get; set; } =
+			obj => new SegueTarget(obj);
+
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public virtual bool IsTemplate {
+			get {
+				switch (target)
+				{
+					case Type _: return true;
+					case DataTemplate _: return true;
+				}
+				return false;
+			}
+		}
+
+		public Page Page {
+			get {
+				if (IsTemplate)
+					throw new InvalidOperationException("Target is a template");
+				return TryCreatePage();
+			}
+		}
+
+		protected SegueTarget(object target)
+		{
+			this.target = target;
+		}
+
+		// Convenience
+		internal Page TryCreatePage()
+		{
+			return (Page)TryCreateValue(typeof(Page));
+		}
+
+		/// <summary>
+		/// For internal use.
+		/// </summary>
+		/// <remarks>
+		/// Generally, you will want to pass <see cref="Page"/> or a platform-specific
+		///  type for <see cref="targetType"/>. This call might be expensive.
+		/// </remarks>
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public virtual object TryCreateValue(Type targetType)
+		{
+			var cached = cachedValue?.Target;
+			if (cached != null && targetType.IsAssignableFrom(cached.GetType()))
+			{
+				cachedValue = null;
+				return cached;
+			}
+			if (targetType.IsAssignableFrom(target.GetType()))
+				return target;
+			switch (target)
+			{
+				case Type ty when targetType.IsAssignableFrom(ty):
+					return Activator.CreateInstance(ty);
+
+				case DataTemplate dt when templatedType == null || targetType.IsAssignableFrom(templatedType):
+				{
+					var content = dt.CreateContent();
+					if (templatedType != null)
+						return content;
+
+					templatedType = content.GetType();
+					if (targetType.IsAssignableFrom(templatedType))
+						return content;
+
+					// Oops, we can't use content this time. But at least we have
+					//  a chance of using it next time if it's not collected..
+					Reject(content);
+					break;
+				}
+			}
+			return null;
+		}
+
+		protected void Reject(object value)
+		{
+			if (IsTemplate)
+				cachedValue = new WeakReference(value);
+		}
+
+		protected static SegueTarget CreateFromObject(object obj)
+		{
+			return (obj == null) ? null : CreateFromObjectHandler(obj);
+		}
+
+		public static implicit operator SegueTarget(Type ty) => CreateFromObject(ty);
+		public static implicit operator SegueTarget(DataTemplate dt) => CreateFromObject(dt);
+
+		// The conversion from Page is explicit because we don't want people accidently
+		//  using raw Page in XAML when they should be using DataTemplate..
+		public static explicit operator SegueTarget(Page page) => CreateFromObject(page);
+	}
+}
diff --git a/Xamarin.Forms.Core/Segues/ValueSegue.cs b/Xamarin.Forms.Core/Segues/ValueSegue.cs
new file mode 100644
index 00000000000..c64f4933a45
--- /dev/null
+++ b/Xamarin.Forms.Core/Segues/ValueSegue.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Windows.Input;
+using System.ComponentModel;
+using System.Threading.Tasks;
+
+namespace Xamarin.Forms.Internals
+{
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public struct ValueSegue
+	{
+		Segue segue; // may be null
+		NavigationAction action;
+		bool animated;
+
+		public Segue Segue => segue;
+		public NavigationAction Action => segue?.Action ?? action;
+		public bool IsAnimated => segue?.IsAnimated ?? animated;
+		public bool IsEnabled => segue?.IsEnabled ?? true;
+
+		public ValueSegue(Segue segue) : this()
+		{
+			this.segue = segue;
+		}
+
+		public ValueSegue(NavigationAction action, bool animated)
+		{
+			this.segue = null;
+			this.action = action;
+			this.animated = animated;
+		}
+
+		public ICommand ToCommand(Element source)
+		{
+			if (segue != null)
+				return segue.ToCommand(source);
+
+			return Segue.CreateCommand(source, action, animated);
+		}
+
+		public bool CanExecuteCommand(Element source, object parameter)
+		{
+			if (segue != null)
+				return segue.CanExecuteCommand(source, parameter);
+
+			return Segue.DefaultCanExecuteCommand(this, source);
+		}
+
+		public Task ExecuteCommand(Element source, object parameter)
+		{
+			if (segue != null)
+				return segue.ExecuteCommand(source, parameter);
+
+			return Segue.DefaultExecuteCommand(this, source);
+		}
+
+		public Segue GetOrCreateSegue()
+		{
+			return segue ?? new Segue { Action = action, IsAnimated = animated };
+		}
+
+		public static implicit operator ValueSegue(Segue seg) => new ValueSegue(seg);
+	}
+}
diff --git a/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj b/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj
index c4af941cb0f..1f84a7e54d8 100644
--- a/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj
+++ b/Xamarin.Forms.Core/Xamarin.Forms.Core.csproj
@@ -16,5 +16,8 @@
     <PackageReference Include="System.ComponentModel" Version="4.3.0" />
     <PackageReference Include="System.Dynamic.Runtime" Version="4.3.0" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Segues\" />
+  </ItemGroup>
   <Import Project="..\Xamarin.Flex\Xamarin.Flex.projitems" Label="Shared" Condition="Exists('..\Xamarin.Flex\Xamarin.Flex.projitems')" />
 </Project>
diff --git a/Xamarin.Forms.Xaml/MarkupExtensions/SegueExtension.cs b/Xamarin.Forms.Xaml/MarkupExtensions/SegueExtension.cs
new file mode 100644
index 00000000000..fd47be71448
--- /dev/null
+++ b/Xamarin.Forms.Xaml/MarkupExtensions/SegueExtension.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using System.Windows.Input;
+
+namespace Xamarin.Forms.Xaml
+{
+	[ContentProperty(nameof(SegueExtension.Action))]
+	public class SegueExtension : IMarkupExtension<ICommand>
+	{
+		/// <summary>
+		/// Gets or sets the action that this segue will perform.
+		/// </summary>
+		/// <remarks>
+		/// Values should correspond to values of the <see cref="NavigationAction"/> enumeration. 
+		/// </remarks>
+		public string Action { get; set; }
+
+		/// <summary>
+		/// Gets or sets the type of custom segue to be created.
+		/// </summary>
+		/// Gets or sets a value indicating whether this segue is animated when executed.
+		/// </summary>
+		/// <value><c>true</c> if animated (default); otherwise, <c>false</c>.</value>
+		public bool IsAnimated { get; set; }
+
+		public SegueExtension()
+		{
+			IsAnimated = true;
+		}
+
+		public ICommand ProvideValue(IServiceProvider serviceProvider)
+		{
+			var targetProvider = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
+			if (targetProvider == null)
+				throw new ArgumentException();
+
+			var target = targetProvider.TargetObject as Element;
+			if (target == null)
+				XamlError("Segue may only be used on Elements", serviceProvider);
+
+			var action = default(NavigationAction);
+			if (Action != null && !NavigationActionConverter.TryParse(Action, out action))
+				XamlError($"Unknown segue action \"{Action}\"", serviceProvider);
+
+			return Segue.CreateCommand(target, action, IsAnimated);
+		}
+
+		object IMarkupExtension.ProvideValue(IServiceProvider serviceProvider) => ProvideValue(serviceProvider);
+
+		static void XamlError(string message, IServiceProvider serviceProvider)
+		{
+			var lineInfoProvider = serviceProvider.GetService(typeof(IXmlLineInfoProvider)) as IXmlLineInfoProvider;
+			var lineInfo = lineInfoProvider?.XmlLineInfo ?? new XmlLineInfo();
+			throw new XamlParseException(message, lineInfo);
+		}
+	}
+}

From 774bc22eadefb7464308c683d190411e04f8894b Mon Sep 17 00:00:00 2001
From: Alex Corrado <alexc@xamarin.com>
Date: Tue, 24 Apr 2018 15:27:40 -0400
Subject: [PATCH 3/5] [iOS] Implement Segues for iOS platform

---
 Xamarin.Forms.Platform.iOS/Forms.cs           |  1 +
 Xamarin.Forms.Platform.iOS/Platform.cs        | 86 ++++++++++++++++++-
 .../Renderers/NavigationRenderer.cs           | 66 ++++++++++++++
 .../Segues/ViewControllerSegueTarget.cs       | 74 ++++++++++++++++
 .../Xamarin.Forms.Platform.iOS.csproj         |  4 +
 5 files changed, 227 insertions(+), 4 deletions(-)
 create mode 100644 Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs

diff --git a/Xamarin.Forms.Platform.iOS/Forms.cs b/Xamarin.Forms.Platform.iOS/Forms.cs
index 10c01f0ee3c..4d340f1ecac 100644
--- a/Xamarin.Forms.Platform.iOS/Forms.cs
+++ b/Xamarin.Forms.Platform.iOS/Forms.cs
@@ -105,6 +105,7 @@ public static void Init()
 			Internals.Registrar.RegisterAll(new[]
 				{ typeof(ExportRendererAttribute), typeof(ExportCellAttribute), typeof(ExportImageSourceHandlerAttribute) });
 			ExpressionSearch.Default = new iOSExpressionSearch();
+			ViewControllerSegueTarget.Init();
 		}
 
 		public static event EventHandler<ViewInitializedEventArgs> ViewInitialized;
diff --git a/Xamarin.Forms.Platform.iOS/Platform.cs b/Xamarin.Forms.Platform.iOS/Platform.cs
index 6b23f1bafaa..0355167331d 100644
--- a/Xamarin.Forms.Platform.iOS/Platform.cs
+++ b/Xamarin.Forms.Platform.iOS/Platform.cs
@@ -175,6 +175,80 @@ Task INavigation.PushModalAsync(Page modal, bool animated)
 			return Task.FromResult<object>(null);
 		}
 
+		Task INavigation.ShowAsync(Page page)
+		{
+			return ((INavigation)this).ShowAsync(page, true);
+		}
+
+		Task INavigation.ShowAsync(Page page, bool animated)
+		{
+			return ((INavigation)this).PushModalAsync(page, animated);
+		}
+
+		async Task INavigation.SegueAsync(Segue segue, SegueTarget target)
+		{
+			var action = segue.Action;
+			switch (action)
+			{
+				case NavigationAction.Pop:
+					action = NavigationAction.PopModal;
+					goto case NavigationAction.PopModal;
+				case NavigationAction.PopModal:
+					target = (SegueTarget)_modals.Last();
+					break;
+				case NavigationAction.Show:
+				case NavigationAction.Modal:
+				case NavigationAction.MainPage:
+					break; // these are ok
+				default:
+					throw new InvalidOperationException($"{action} is not supported globally on iOS, please use a NavigationPage.");
+			}
+
+			var vc = (UIViewController)target.TryCreateValue(typeof(UIViewController));
+			if (vc == null)
+				throw new ArgumentException("Unsupported target type", nameof(target));
+
+			if (vc.ParentViewController is ModalWrapper wrapper)
+				vc = wrapper;
+
+			// adjust target if needed
+			var exec = segue as ISegueExecution;
+			if (exec != null)
+			{
+				// If we're popping a modal, the real target is the presenting view controller
+				if (action == NavigationAction.PopModal)
+					target = new ViewControllerSegueTarget(vc.PresentingViewController);
+				else if (target.IsTemplate)
+					target = new ViewControllerSegueTarget(vc);
+
+				if (!await exec.OnBeforeExecute(target))
+					return;
+			}
+
+			// If we don't need a target, or can retrieve it as a Page, route it through classic Forms navigation..
+			Page page = null;
+			if (!action.RequiresTarget() || (page = ViewControllerSegueTarget.GetPage(vc)) != null)
+			{
+				await this.NavigateAsync(action, page, segue.IsAnimated);
+				return;
+			}
+
+			// Otherwise, perform a native transition..
+			switch (action)
+			{
+				case NavigationAction.Show:
+				case NavigationAction.Modal:
+					await PresentModal(vc, segue.IsAnimated);
+					break;
+				case NavigationAction.MainPage:
+					var wnd = UIApplication.SharedApplication.Delegate?.GetWindow();
+					if (wnd == null)
+						throw new InvalidOperationException("Cannot get window. Ensure your app delegate implements the Window property");
+					wnd.RootViewController = vc;
+					break;
+			}
+		}
+
 		void INavigation.RemovePage(Page page)
 		{
 			throw new InvalidOperationException("RemovePage is not supported globally on iOS, please use a NavigationPage.");
@@ -451,7 +525,7 @@ static void PresentPopUp(UIWindow window, UIAlertController alert, ActionSheetAr
 			window.RootViewController.PresentViewController(alert, true, null);
 		}
 
-		async Task PresentModal(Page modal, bool animated)
+		Task PresentModal(Page modal, bool animated)
 		{
 			var modalRenderer = GetRenderer(modal);
 			if (modalRenderer == null)
@@ -461,14 +535,18 @@ async Task PresentModal(Page modal, bool animated)
 			}
 
 			var wrapper = new ModalWrapper(modalRenderer);
+			return PresentModal(wrapper, animated);
+		}
 
+		async Task PresentModal(UIViewController modal, bool animated)
+		{
 			if (_modals.Count > 1)
 			{
 				var topPage = _modals[_modals.Count - 2];
 				var controller = GetRenderer(topPage) as UIViewController;
 				if (controller != null)
 				{
-					await controller.PresentViewControllerAsync(wrapper, animated);
+					await controller.PresentViewControllerAsync(modal, animated);
 					await Task.Delay(5);
 					return;
 				}
@@ -478,7 +556,7 @@ async Task PresentModal(Page modal, bool animated)
 			// presentation is complete before it really is. It does not however inform you when it is really done (and thus 
 			// would be safe to dismiss the VC). Fortunately this is almost never an issue
 			
-			await _renderer.PresentViewControllerAsync(wrapper, animated);
+			await _renderer.PresentViewControllerAsync(modal, animated);
 			await Task.Delay(5);
 		}
 
@@ -545,4 +623,4 @@ public override UIView HitTest(CGPoint point, UIEvent uievent)
 			}
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs
index decec294e41..0f399e9af94 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs
@@ -218,6 +218,7 @@ public override void ViewDidLoad()
 			navPage.PopToRootRequested += OnPopToRootRequested;
 			navPage.RemovePageRequested += OnRemovedPageRequested;
 			navPage.InsertPageBeforeRequested += OnInsertPageBeforeRequested;
+			navPage.SegueRequested += OnSegueRequested;
 
 			UpdateTint();
 			UpdateBarBackgroundColor();
@@ -258,6 +259,7 @@ protected override void Dispose(bool disposing)
 				var navPage = (NavigationPage)Element;
 				navPage.PropertyChanged -= HandlePropertyChanged;
 
+				navPage.SegueRequested -= OnSegueRequested;
 				navPage.PushRequested -= OnPushRequested;
 				navPage.PopRequested -= OnPopRequested;
 				navPage.PopToRootRequested -= OnPopToRootRequested;
@@ -536,6 +538,70 @@ void OnPushRequested(object sender, NavigationRequestedEventArgs e)
 			e.Task = PushPageAsync(e.Page, e.Animated);
 		}
 
+		void OnSegueRequested(object sender, SegueRequestedEventArgs e)
+		{
+			e.Task = SegueAsync(e.Segue, e.Target);
+		}
+
+		async Task SegueAsync(ValueSegue seg, SegueTarget target)
+		{
+			var action = seg.Action;
+			var exec = seg.Segue as ISegueExecution;
+			UIViewController vc = null;
+
+			// adjust target and action as needed
+			switch (action)
+			{
+				case NavigationAction.Pop:
+					action = NavigationAction.PopPushed;
+					goto case NavigationAction.PopPushed;
+
+				case NavigationAction.PopPushed:
+					if (exec != null)
+					{
+						var stack = ViewControllers;
+						vc = stack[stack.Length - 2];
+					}
+					break;
+
+				case NavigationAction.PopToRoot:
+					if (exec != null)
+						vc = ViewControllers[0];
+					break;
+			}
+
+			if (vc == null)
+			{
+				vc = (UIViewController)target.TryCreateValue(typeof(UIViewController));
+				if (vc == null)
+					throw new ArgumentException("Unsupported target type", nameof(target));
+			}
+			if (exec != null)
+			{
+				target = new ViewControllerSegueTarget(vc); // clone so we don't risk recreating it
+				if (!await exec.OnBeforeExecute(target))
+					return;
+			}
+
+			// If we don't need a target, or can retrieve it as a Page, route it through classic Forms navigation..
+			Page page = null;
+			if (!action.RequiresTarget() || (page = ViewControllerSegueTarget.GetPage(vc)) != null)
+			{
+				await Element.Navigation.NavigateAsync(action, page, seg.IsAnimated);
+				return;
+			}
+
+			// Otherwise, perform a native transition..
+			switch (action)
+			{
+				case NavigationAction.Show:
+				case NavigationAction.Push:
+					//FIXME: figure out how to await this
+					PushViewController(vc, seg.IsAnimated);
+					return;
+			}
+		}
+
 		void OnRemovedPageRequested(object sender, NavigationRequestedEventArgs e)
 		{
 			RemovePage(e.Page);
diff --git a/Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs b/Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs
new file mode 100644
index 00000000000..d4805098590
--- /dev/null
+++ b/Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Diagnostics.Contracts;
+using System.Linq;
+
+using UIKit;
+
+using Xamarin.Forms.Platform.iOS;
+
+namespace Xamarin.Forms
+{
+	public class ViewControllerSegueTarget : SegueTarget
+	{
+		internal static void Init()
+		{
+			SegueTarget.CreateFromObjectHandler = obj => new ViewControllerSegueTarget(obj);
+		}
+
+		public UIViewController ViewController {
+			get {
+				if (IsTemplate)
+					throw new InvalidOperationException("Target is a template");
+				return (UIViewController)TryCreateValue(typeof(UIViewController));
+			}
+		}
+
+		protected ViewControllerSegueTarget(object obj) : base(obj)
+		{
+		}
+
+		public ViewControllerSegueTarget(UIViewController viewController)
+			: base (viewController)
+		{
+			if (viewController == null)
+				throw new ArgumentNullException();
+		}
+
+		public override object TryCreateValue(Type targetType)
+		{
+			var result = base.TryCreateValue(targetType);
+			if (result == null)
+			{
+				if (targetType.IsAssignableFrom(typeof(Page)))
+				{
+					var vc = (UIViewController)TryCreateValue(typeof(UIViewController));
+					result = GetPage(vc);
+					if (result == null)
+						Reject(vc);
+				}
+				else if (targetType.IsAssignableFrom(typeof(UIViewController)))
+				{
+					var page = (Page)base.TryCreateValue(typeof(Page));
+					if (page == null)
+						return null;
+
+					var renderer = Platform.iOS.Platform.GetRenderer(page);
+					if (renderer == null)
+					{
+						renderer = Platform.iOS.Platform.CreateRenderer(page);
+						Platform.iOS.Platform.SetRenderer(page, renderer);
+					}
+					return renderer.ViewController;
+				}
+			}
+			return result;
+		}
+
+		internal static Page GetPage(UIViewController vc)
+		{
+			if (vc == null)
+				return null;
+			return ((vc as IVisualElementRenderer)?.Element as Page) ?? GetPage(vc.ChildViewControllers.FirstOrDefault());
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj b/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
index 92bbf7f143f..52c6b9e8cb2 100644
--- a/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
+++ b/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
@@ -139,6 +139,7 @@
     <Compile Include="Extensions\LayoutExtensions.cs" />
     <Compile Include="NativeValueConverterService.cs" />
     <Compile Include="NativeBindingService.cs" />
+    <Compile Include="Segues\ViewControllerSegueTarget.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources\StringResources.ar.resx" />
@@ -194,4 +195,7 @@
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Segues\" />
+  </ItemGroup>
 </Project>
\ No newline at end of file

From 9fbdd9f0fe2c5b507535805acae4d1c740531cca Mon Sep 17 00:00:00 2001
From: Alex Corrado <alexc@xamarin.com>
Date: Wed, 16 May 2018 21:35:09 -0400
Subject: [PATCH 4/5] [Segues] Add NativePageWrapper which ensures SegueTarget
 can always translate to a Page

This vastly simplifies things.

Note: this includes an iOS renderer, but there seems to be a bug with it that will need
to be addressed.
---
 Xamarin.Forms.Core/Application.cs             |   7 +-
 .../Internals/SegueRequestedEventArgs.cs      |   1 +
 Xamarin.Forms.Core/NavigationPage.cs          |  76 ++++++++----
 Xamarin.Forms.Core/NavigationProxy.cs         |  15 +--
 Xamarin.Forms.Core/Segues/SegueExtensions.cs  |   8 +-
 Xamarin.Forms.Core/Segues/SegueTarget.cs      | 110 +++++-------------
 Xamarin.Forms.Core/Segues/ValueSegue.cs       |   5 -
 Xamarin.Forms.Platform.iOS/Forms.cs           |   1 -
 .../NativePageWrapper.cs                      |  16 +++
 .../NativePageWrapperRenderer.cs              |  54 +++++++++
 .../NativeValueConverterService.cs            |  11 +-
 Xamarin.Forms.Platform.iOS/PageExtensions.cs  |   5 +
 Xamarin.Forms.Platform.iOS/Platform.cs        |  69 +++--------
 .../Properties/AssemblyInfo.cs                |   3 +-
 .../Renderers/NavigationRenderer.cs           |  68 +----------
 .../Segues/ViewControllerSegueTarget.cs       |  57 ++-------
 .../Xamarin.Forms.Platform.iOS.csproj         |   2 +
 17 files changed, 203 insertions(+), 305 deletions(-)
 create mode 100644 Xamarin.Forms.Platform.iOS/NativePageWrapper.cs
 create mode 100644 Xamarin.Forms.Platform.iOS/NativePageWrapperRenderer.cs

diff --git a/Xamarin.Forms.Core/Application.cs b/Xamarin.Forms.Core/Application.cs
index a44f5284014..ed858414ce8 100644
--- a/Xamarin.Forms.Core/Application.cs
+++ b/Xamarin.Forms.Core/Application.cs
@@ -399,12 +399,7 @@ async Task<Page> OnPopModal(ValueSegue segue)
 
 			async Task OnPushModal(ValueSegue segue, SegueTarget target)
 			{
-				var modal = target.TryCreatePage();
-				if (modal == null)
-				{
-					await base.OnSegue(segue, target);
-					return;
-				}
+				var modal = target.ToPage();
 
 				// IMPORTANT! If the target was a template, create a new SegueTarget from
 				//  the instantiated page.
diff --git a/Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs b/Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs
index a09d4e33ff7..af5929276fd 100644
--- a/Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs
+++ b/Xamarin.Forms.Core/Internals/SegueRequestedEventArgs.cs
@@ -9,6 +9,7 @@ public class SegueRequestedEventArgs
 		public ValueSegue Segue { get; }
 		public SegueTarget Target { get; }
 		public Task Task { get; set; }
+		public bool Handled { get; set; }
 
 		internal SegueRequestedEventArgs(ValueSegue segue, SegueTarget target)
 		{
diff --git a/Xamarin.Forms.Core/NavigationPage.cs b/Xamarin.Forms.Core/NavigationPage.cs
index f66e21a8fac..6337cc07641 100644
--- a/Xamarin.Forms.Core/NavigationPage.cs
+++ b/Xamarin.Forms.Core/NavigationPage.cs
@@ -402,16 +402,64 @@ void PushPage(Page page)
 			CurrentPage = page;
 		}
 
-		async Task SegueAsyncInner(ValueSegue segue, SegueTarget target)
+		async Task SegueAsyncInner(ValueSegue seg, SegueTarget target)
 		{
+			var exec = seg.Segue as ISegueExecution;
+			if (exec != null)
+			{
+				switch (seg.Action)
+				{
+					case NavigationAction.Show:
+					case NavigationAction.Push:
+						if (target.IsTemplate)
+							target = (SegueTarget)target.ToPage();
+						break;
+					case NavigationAction.Pop:
+					case NavigationAction.PopPushed:
+						var page = (Page)InternalChildren[InternalChildren.Count - 2];
+						target = (SegueTarget)page;
+						break;
+
+					case NavigationAction.PopToRoot:
+						target = (SegueTarget)RootPage;
+						break;
+				}
+				if (!await exec.OnBeforeExecute(target))
+					return;
+			}
+
+			var handled = false;
+
 			EventHandler<SegueRequestedEventArgs> requestSegue = SegueRequested;
 			if (requestSegue != null)
 			{
-				var args = new SegueRequestedEventArgs(segue, target);
+				var args = new SegueRequestedEventArgs(seg, target);
 				requestSegue(this, args);
 
 				if (args.Task != null)
 					await args.Task;
+
+				handled = args.Handled;
+			}
+
+			if (!handled)
+			{
+				switch (seg.Action)
+				{
+					case NavigationAction.Show:
+					case NavigationAction.Push:
+						await PushAsyncInner(target.ToPage(), seg.IsAnimated);
+						break;
+
+					case NavigationAction.Pop:
+					case NavigationAction.PopPushed:
+						await PopAsyncInner(seg.IsAnimated, false);
+						break;
+
+					case NavigationAction.PopToRoot:
+						await PopToRootAsyncInner(seg.IsAnimated);
+						break;
+				}
 			}
 		}
 
@@ -473,34 +521,16 @@ protected override void OnInsertPageBefore(Page page, Page before)
 
 			protected internal override Task OnSegue(ValueSegue seg, SegueTarget target)
 			{
-				var action = seg.Action;
-				switch (action)
-				{
-					case NavigationAction.Modal:
-					case NavigationAction.MainPage:
-					case NavigationAction.PopModal:
-					case NavigationAction.Pop when this.ShouldPopModal():
-						return base.OnSegue(seg, target);
-				}
-
-				Page page = null;
-				if (seg.Segue != null || (target != null && (page = target.TryCreatePage()) == null))
-					return Owner.SegueAsync(seg, target);
-
-				switch (action)
+				switch (seg.Action)
 				{
 					case NavigationAction.Show:
 					case NavigationAction.Push:
-						return Owner.PushAsync(page, seg.IsAnimated);
-
 					case NavigationAction.Pop:
 					case NavigationAction.PopPushed:
-						return Owner.PopAsync(seg.IsAnimated);
 					case NavigationAction.PopToRoot:
-						return Owner.PopToRootAsync(seg.IsAnimated);
+						return Owner.SegueAsync(seg, target);
 				}
-
-				throw new NotSupportedException(action.ToString());
+				return base.OnSegue(seg, target);
 			}
 
 			protected override void OnRemovePage(Page page)
diff --git a/Xamarin.Forms.Core/NavigationProxy.cs b/Xamarin.Forms.Core/NavigationProxy.cs
index f74f44e490d..d41b27e475c 100644
--- a/Xamarin.Forms.Core/NavigationProxy.cs
+++ b/Xamarin.Forms.Core/NavigationProxy.cs
@@ -178,25 +178,16 @@ protected internal virtual Task OnSegue(ValueSegue segue, SegueTarget target)
 			INavigation currentInner = Inner;
 			if (currentInner == null)
 			{
-				Page page = null;
-				if (segue.Action.RequiresTarget())
-				{
-					if (target == null)
-						throw new ArgumentNullException(nameof(target));
-					page = (Page)target.TryCreatePage();
-					if (page == null)
-						throw new InvalidOperationException($"Navigation must be rooted for non-Page target");
-				}
 				switch (segue.Action)
 				{
 					case NavigationAction.Show:
 						throw new InvalidOperationException($"Navigation must be rooted to use {nameof(NavigationAction.Show)}");
 
 					case NavigationAction.Push:
-						_pushStack.Value.Add(page);
+						_pushStack.Value.Add(target.ToPage());
 						return Task.CompletedTask;
 					case NavigationAction.Modal:
-						_modalStack.Value.Add(page);
+						_modalStack.Value.Add(target.ToPage());
 						return Task.CompletedTask;
 
 					// It's important these Pop* cases (except PopToRoot) return Task<Page>
@@ -213,7 +204,7 @@ protected internal virtual Task OnSegue(ValueSegue segue, SegueTarget target)
 						_pushStack.Value.Add(root);
 						return Task.CompletedTask;
 				}
-				return this.NavigateAsync(segue.Action, page, segue.IsAnimated);
+				return this.NavigateAsync(segue.Action, target, segue.IsAnimated);
 			}
 			return currentInner.SegueAsync(segue, target);
 		}
diff --git a/Xamarin.Forms.Core/Segues/SegueExtensions.cs b/Xamarin.Forms.Core/Segues/SegueExtensions.cs
index 60a163dd769..1afe9fea5fe 100644
--- a/Xamarin.Forms.Core/Segues/SegueExtensions.cs
+++ b/Xamarin.Forms.Core/Segues/SegueExtensions.cs
@@ -53,12 +53,10 @@ internal static Task SegueAsync(this INavigation nav, ValueSegue seg, SegueTarge
 				return proxy.OnSegue(seg, target);
 
 			// If this is a simple navigation, bypass the Segue machinery...
-			Page page = null;
-			if (seg.Segue == null && (target == null || (page = target.TryCreatePage()) != null))
-				return nav.NavigateAsync(seg.Action, page, seg.IsAnimated);
+			if (seg.Segue == null)
+				return nav.NavigateAsync(seg.Action, target?.ToPage(), seg.IsAnimated);
 
-			// This is potentially the most expensive..
-			return nav.SegueAsync(seg.GetOrCreateSegue(), target);
+			return nav.SegueAsync(seg.Segue, target);
 		}
 
 		public static void SetSegue(this ICommandableElement trigger, Segue segue, SegueTarget target)
diff --git a/Xamarin.Forms.Core/Segues/SegueTarget.cs b/Xamarin.Forms.Core/Segues/SegueTarget.cs
index 13cd6c21b0f..87347c4e790 100644
--- a/Xamarin.Forms.Core/Segues/SegueTarget.cs
+++ b/Xamarin.Forms.Core/Segues/SegueTarget.cs
@@ -1,114 +1,60 @@
 using System;
 using System.ComponentModel;
 
+using Xamarin.Forms.Xaml;
+
 namespace Xamarin.Forms
 {
 	public class SegueTarget
 	{
-		object target;
-
-		// This is set in the DataTemplate case below, or when Reject is called
-		WeakReference cachedValue;
-
-		// We don't know what type a DataTemplate will construct until we actually create it.
-		//  Here we attempt to avoid creating a lot of garbage when TryCreateValue is called
-		//  for types other than what our DataTemplate returns..
-		Type templatedType;
-
-		// Allow platforms to register their own SegueTarget subclasses that will
-		//  be used for implicit conversion from DataTemplate, etc..
-		protected static Func<object,SegueTarget> CreateFromObjectHandler { private get; set; } =
-			obj => new SegueTarget(obj);
+		readonly Page target;
+		readonly DataTemplate template;
 
-		[EditorBrowsable(EditorBrowsableState.Never)]
-		public virtual bool IsTemplate {
-			get {
-				switch (target)
-				{
-					case Type _: return true;
-					case DataTemplate _: return true;
-				}
-				return false;
-			}
-		}
+		public bool IsTemplate => template != null;
 
-		public Page Page {
-			get {
-				if (IsTemplate)
-					throw new InvalidOperationException("Target is a template");
-				return TryCreatePage();
-			}
+		public SegueTarget(Page target)
+		{
+			if (target == null)
+				throw new ArgumentNullException (nameof(target));
+			this.target = target;
 		}
 
-		protected SegueTarget(object target)
+		public SegueTarget(DataTemplate template)
 		{
-			this.target = target;
+			if (template == null)
+				throw new ArgumentNullException(nameof(template));
+			this.template = template;
 		}
 
-		// Convenience
-		internal Page TryCreatePage()
+		protected SegueTarget()
 		{
-			return (Page)TryCreateValue(typeof(Page));
 		}
 
 		/// <summary>
-		/// For internal use.
+		/// Gets or creates the <see cref="Page"/> for this <see cref="SegueTarget"/>
 		/// </summary>
 		/// <remarks>
-		/// Generally, you will want to pass <see cref="Page"/> or a platform-specific
-		///  type for <see cref="targetType"/>. This call might be expensive.
+		/// If this instance was created directly from a <see cref="Page"/>, returns that instance.
+		///  Otherwise, attempts to instantiate a new page from the <see cref="DataTemplate"/>.
 		/// </remarks>
-		[EditorBrowsable(EditorBrowsableState.Never)]
-		public virtual object TryCreateValue(Type targetType)
+		public virtual Page ToPage()
 		{
-			var cached = cachedValue?.Target;
-			if (cached != null && targetType.IsAssignableFrom(cached.GetType()))
-			{
-				cachedValue = null;
-				return cached;
-			}
-			if (targetType.IsAssignableFrom(target.GetType()))
+			if (target != null)
 				return target;
-			switch (target)
-			{
-				case Type ty when targetType.IsAssignableFrom(ty):
-					return Activator.CreateInstance(ty);
 
-				case DataTemplate dt when templatedType == null || targetType.IsAssignableFrom(templatedType):
-				{
-					var content = dt.CreateContent();
-					if (templatedType != null)
-						return content;
+			var obj = template.CreateContent();
+			if (obj is Page page)
+				return page;
 
-					templatedType = content.GetType();
-					if (targetType.IsAssignableFrom(templatedType))
-						return content;
-
-					// Oops, we can't use content this time. But at least we have
-					//  a chance of using it next time if it's not collected..
-					Reject(content);
-					break;
-				}
-			}
-			return null;
-		}
-
-		protected void Reject(object value)
-		{
-			if (IsTemplate)
-				cachedValue = new WeakReference(value);
-		}
-
-		protected static SegueTarget CreateFromObject(object obj)
-		{
-			return (obj == null) ? null : CreateFromObjectHandler(obj);
+			// This could be a native object that we can convert to a page..
+			return obj.ConvertTo(typeof(Page), (Func<object>)null, null) as Page;
 		}
 
-		public static implicit operator SegueTarget(Type ty) => CreateFromObject(ty);
-		public static implicit operator SegueTarget(DataTemplate dt) => CreateFromObject(dt);
+		public static implicit operator SegueTarget(Type ty) => (ty == null) ? null : new SegueTarget(new DataTemplate(ty));
+		public static implicit operator SegueTarget(DataTemplate dt) => (dt == null) ? null : new SegueTarget(dt);
 
 		// The conversion from Page is explicit because we don't want people accidently
 		//  using raw Page in XAML when they should be using DataTemplate..
-		public static explicit operator SegueTarget(Page page) => CreateFromObject(page);
+		public static explicit operator SegueTarget(Page page) => (page == null) ? null : new SegueTarget(page);
 	}
 }
diff --git a/Xamarin.Forms.Core/Segues/ValueSegue.cs b/Xamarin.Forms.Core/Segues/ValueSegue.cs
index c64f4933a45..f28d17b0892 100644
--- a/Xamarin.Forms.Core/Segues/ValueSegue.cs
+++ b/Xamarin.Forms.Core/Segues/ValueSegue.cs
@@ -53,11 +53,6 @@ public Task ExecuteCommand(Element source, object parameter)
 			return Segue.DefaultExecuteCommand(this, source);
 		}
 
-		public Segue GetOrCreateSegue()
-		{
-			return segue ?? new Segue { Action = action, IsAnimated = animated };
-		}
-
 		public static implicit operator ValueSegue(Segue seg) => new ValueSegue(seg);
 	}
 }
diff --git a/Xamarin.Forms.Platform.iOS/Forms.cs b/Xamarin.Forms.Platform.iOS/Forms.cs
index 4d340f1ecac..10c01f0ee3c 100644
--- a/Xamarin.Forms.Platform.iOS/Forms.cs
+++ b/Xamarin.Forms.Platform.iOS/Forms.cs
@@ -105,7 +105,6 @@ public static void Init()
 			Internals.Registrar.RegisterAll(new[]
 				{ typeof(ExportRendererAttribute), typeof(ExportCellAttribute), typeof(ExportImageSourceHandlerAttribute) });
 			ExpressionSearch.Default = new iOSExpressionSearch();
-			ViewControllerSegueTarget.Init();
 		}
 
 		public static event EventHandler<ViewInitializedEventArgs> ViewInitialized;
diff --git a/Xamarin.Forms.Platform.iOS/NativePageWrapper.cs b/Xamarin.Forms.Platform.iOS/NativePageWrapper.cs
new file mode 100644
index 00000000000..7537d8c50ff
--- /dev/null
+++ b/Xamarin.Forms.Platform.iOS/NativePageWrapper.cs
@@ -0,0 +1,16 @@
+using System;
+
+using UIKit;
+
+namespace Xamarin.Forms.Platform.iOS
+{
+	public class NativePageWrapper : Page
+	{
+		public UIViewController ViewController { get; }
+
+		public NativePageWrapper (UIViewController viewController)
+		{
+			ViewController = viewController;
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.iOS/NativePageWrapperRenderer.cs b/Xamarin.Forms.Platform.iOS/NativePageWrapperRenderer.cs
new file mode 100644
index 00000000000..bb5a0a5f6ea
--- /dev/null
+++ b/Xamarin.Forms.Platform.iOS/NativePageWrapperRenderer.cs
@@ -0,0 +1,54 @@
+using System;
+
+using UIKit;
+using CoreGraphics;
+
+namespace Xamarin.Forms.Platform.iOS
+{
+	public class NativePageWrapperRenderer : IVisualElementRenderer {
+
+		public event EventHandler<VisualElementChangedEventArgs> ElementChanged;
+
+		public NativePageWrapper Element { get; private set; }
+
+		VisualElement IVisualElementRenderer.Element => Element;
+
+		public UIView NativeView => Element?.ViewController.View;
+
+		public UIViewController ViewController => Element?.ViewController;
+
+		public SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint)
+		{
+			return NativeView.GetSizeRequest(widthConstraint, heightConstraint);
+		}
+
+		public void SetElement(VisualElement element)
+		{
+			VisualElement oldElement = Element;
+			Element = (NativePageWrapper)element;
+
+			OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
+		}
+
+		protected virtual void OnElementChanged(VisualElementChangedEventArgs e)
+		{
+			ElementChanged?.Invoke(this, e);
+		}
+
+		public void SetElementSize(Size size)
+		{
+			NativeView.Frame = new CGRect(0, 0, size.Width, size.Height);
+			Element.Layout(new Rectangle(Element.X, Element.Y, size.Width, size.Height));
+		}
+
+		protected virtual void Dispose(bool disposing)
+		{
+			if (disposing && Element != null) {
+				Platform.SetRenderer(Element, null);
+				Element = null;
+			}
+		}
+
+		public void Dispose() => Dispose(true);
+	}
+}
diff --git a/Xamarin.Forms.Platform.iOS/NativeValueConverterService.cs b/Xamarin.Forms.Platform.iOS/NativeValueConverterService.cs
index d2ead78685c..da8767865ee 100644
--- a/Xamarin.Forms.Platform.iOS/NativeValueConverterService.cs
+++ b/Xamarin.Forms.Platform.iOS/NativeValueConverterService.cs
@@ -19,10 +19,15 @@ class NativeValueConverterService : INativeValueConverterService
 		public bool ConvertTo(object value, Type toType, out object nativeValue)
 		{
 			nativeValue = null;
-			if (typeof(UIView).IsInstanceOfType(value) && toType.IsAssignableFrom(typeof(View)))
+			switch (value)
 			{
-				nativeValue = ((UIView)value).ToView();
-				return true;
+				case UIView nativeView when toType.IsAssignableFrom(typeof(View)):
+					nativeValue = nativeView.ToView();
+					return true;
+
+				case UIViewController nativeViewController when toType.IsAssignableFrom(typeof(Page)):
+					nativeValue = nativeViewController.ToPage();
+					return true;
 			}
 			return false;
 		}
diff --git a/Xamarin.Forms.Platform.iOS/PageExtensions.cs b/Xamarin.Forms.Platform.iOS/PageExtensions.cs
index 808c6c37561..1b4bfb462be 100644
--- a/Xamarin.Forms.Platform.iOS/PageExtensions.cs
+++ b/Xamarin.Forms.Platform.iOS/PageExtensions.cs
@@ -35,5 +35,10 @@ public static UIViewController CreateViewController(this ContentPage page)
 		{
 			return Xamarin.Forms.PageExtensions.CreateViewController(page);
 		}
+
+		public static Page ToPage(this UIViewController viewController)
+		{
+			return new NativePageWrapper(viewController);
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.iOS/Platform.cs b/Xamarin.Forms.Platform.iOS/Platform.cs
index 0355167331d..44b0fa364ab 100644
--- a/Xamarin.Forms.Platform.iOS/Platform.cs
+++ b/Xamarin.Forms.Platform.iOS/Platform.cs
@@ -187,66 +187,35 @@ Task INavigation.ShowAsync(Page page, bool animated)
 
 		async Task INavigation.SegueAsync(Segue segue, SegueTarget target)
 		{
+			Page page = null;
 			var action = segue.Action;
+
+			// adjust target and action as needed
 			switch (action)
 			{
 				case NavigationAction.Pop:
-					action = NavigationAction.PopModal;
-					goto case NavigationAction.PopModal;
 				case NavigationAction.PopModal:
-					target = (SegueTarget)_modals.Last();
+					page = _modals.Last();
+					action = NavigationAction.PopModal;
+					var controller = GetRenderer(page)?.ViewController.PresentingViewController;
+					if (controller != null)
+						target = new ViewControllerSegueTarget(controller);
 					break;
 				case NavigationAction.Show:
 				case NavigationAction.Modal:
 				case NavigationAction.MainPage:
-					break; // these are ok
+					page = target.ToPage();
+					if (target.IsTemplate)
+						target = (SegueTarget)page;
+					break;
 				default:
 					throw new InvalidOperationException($"{action} is not supported globally on iOS, please use a NavigationPage.");
 			}
 
-			var vc = (UIViewController)target.TryCreateValue(typeof(UIViewController));
-			if (vc == null)
-				throw new ArgumentException("Unsupported target type", nameof(target));
-
-			if (vc.ParentViewController is ModalWrapper wrapper)
-				vc = wrapper;
-
-			// adjust target if needed
-			var exec = segue as ISegueExecution;
-			if (exec != null)
-			{
-				// If we're popping a modal, the real target is the presenting view controller
-				if (action == NavigationAction.PopModal)
-					target = new ViewControllerSegueTarget(vc.PresentingViewController);
-				else if (target.IsTemplate)
-					target = new ViewControllerSegueTarget(vc);
-
-				if (!await exec.OnBeforeExecute(target))
-					return;
-			}
-
-			// If we don't need a target, or can retrieve it as a Page, route it through classic Forms navigation..
-			Page page = null;
-			if (!action.RequiresTarget() || (page = ViewControllerSegueTarget.GetPage(vc)) != null)
-			{
-				await this.NavigateAsync(action, page, segue.IsAnimated);
+			if (!await ((ISegueExecution)segue).OnBeforeExecute(target))
 				return;
-			}
 
-			// Otherwise, perform a native transition..
-			switch (action)
-			{
-				case NavigationAction.Show:
-				case NavigationAction.Modal:
-					await PresentModal(vc, segue.IsAnimated);
-					break;
-				case NavigationAction.MainPage:
-					var wnd = UIApplication.SharedApplication.Delegate?.GetWindow();
-					if (wnd == null)
-						throw new InvalidOperationException("Cannot get window. Ensure your app delegate implements the Window property");
-					wnd.RootViewController = vc;
-					break;
-			}
+			await this.NavigateAsync(action, page, segue.IsAnimated);
 		}
 
 		void INavigation.RemovePage(Page page)
@@ -525,7 +494,7 @@ static void PresentPopUp(UIWindow window, UIAlertController alert, ActionSheetAr
 			window.RootViewController.PresentViewController(alert, true, null);
 		}
 
-		Task PresentModal(Page modal, bool animated)
+		async Task PresentModal(Page modal, bool animated)
 		{
 			var modalRenderer = GetRenderer(modal);
 			if (modalRenderer == null)
@@ -535,18 +504,14 @@ Task PresentModal(Page modal, bool animated)
 			}
 
 			var wrapper = new ModalWrapper(modalRenderer);
-			return PresentModal(wrapper, animated);
-		}
 
-		async Task PresentModal(UIViewController modal, bool animated)
-		{
 			if (_modals.Count > 1)
 			{
 				var topPage = _modals[_modals.Count - 2];
 				var controller = GetRenderer(topPage) as UIViewController;
 				if (controller != null)
 				{
-					await controller.PresentViewControllerAsync(modal, animated);
+					await controller.PresentViewControllerAsync(wrapper, animated);
 					await Task.Delay(5);
 					return;
 				}
@@ -556,7 +521,7 @@ async Task PresentModal(UIViewController modal, bool animated)
 			// presentation is complete before it really is. It does not however inform you when it is really done (and thus 
 			// would be safe to dismiss the VC). Fortunately this is almost never an issue
 			
-			await _renderer.PresentViewControllerAsync(modal, animated);
+			await _renderer.PresentViewControllerAsync(wrapper, animated);
 			await Task.Delay(5);
 		}
 
diff --git a/Xamarin.Forms.Platform.iOS/Properties/AssemblyInfo.cs b/Xamarin.Forms.Platform.iOS/Properties/AssemblyInfo.cs
index 737f2c560a5..1553961a75e 100644
--- a/Xamarin.Forms.Platform.iOS/Properties/AssemblyInfo.cs
+++ b/Xamarin.Forms.Platform.iOS/Properties/AssemblyInfo.cs
@@ -51,6 +51,7 @@
 
 [assembly: ExportRenderer(typeof(MasterDetailPage), typeof(TabletMasterDetailRenderer), UIUserInterfaceIdiom.Pad)]
 [assembly: ExportRenderer(typeof(NativeViewWrapper), typeof(NativeViewWrapperRenderer))]
+[assembly: ExportRenderer(typeof(NativePageWrapper), typeof(NativePageWrapperRenderer))]
 
 [assembly: ExportCell(typeof(Cell), typeof(CellRenderer))]
 [assembly: ExportCell(typeof(ImageCell), typeof(ImageCellRenderer))]
@@ -67,4 +68,4 @@
 [assembly: Xamarin.Forms.Dependency(typeof(Deserializer))]
 [assembly: Xamarin.Forms.Dependency(typeof(ResourcesProvider))]
 [assembly: ResolutionGroupName("Xamarin")]
-[assembly: Preserve]
\ No newline at end of file
+[assembly: Preserve]
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs
index 0f399e9af94..3d47fec0ab6 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/NavigationRenderer.cs
@@ -218,7 +218,6 @@ public override void ViewDidLoad()
 			navPage.PopToRootRequested += OnPopToRootRequested;
 			navPage.RemovePageRequested += OnRemovedPageRequested;
 			navPage.InsertPageBeforeRequested += OnInsertPageBeforeRequested;
-			navPage.SegueRequested += OnSegueRequested;
 
 			UpdateTint();
 			UpdateBarBackgroundColor();
@@ -259,7 +258,6 @@ protected override void Dispose(bool disposing)
 				var navPage = (NavigationPage)Element;
 				navPage.PropertyChanged -= HandlePropertyChanged;
 
-				navPage.SegueRequested -= OnSegueRequested;
 				navPage.PushRequested -= OnPushRequested;
 				navPage.PopRequested -= OnPopRequested;
 				navPage.PopToRootRequested -= OnPopToRootRequested;
@@ -538,70 +536,6 @@ void OnPushRequested(object sender, NavigationRequestedEventArgs e)
 			e.Task = PushPageAsync(e.Page, e.Animated);
 		}
 
-		void OnSegueRequested(object sender, SegueRequestedEventArgs e)
-		{
-			e.Task = SegueAsync(e.Segue, e.Target);
-		}
-
-		async Task SegueAsync(ValueSegue seg, SegueTarget target)
-		{
-			var action = seg.Action;
-			var exec = seg.Segue as ISegueExecution;
-			UIViewController vc = null;
-
-			// adjust target and action as needed
-			switch (action)
-			{
-				case NavigationAction.Pop:
-					action = NavigationAction.PopPushed;
-					goto case NavigationAction.PopPushed;
-
-				case NavigationAction.PopPushed:
-					if (exec != null)
-					{
-						var stack = ViewControllers;
-						vc = stack[stack.Length - 2];
-					}
-					break;
-
-				case NavigationAction.PopToRoot:
-					if (exec != null)
-						vc = ViewControllers[0];
-					break;
-			}
-
-			if (vc == null)
-			{
-				vc = (UIViewController)target.TryCreateValue(typeof(UIViewController));
-				if (vc == null)
-					throw new ArgumentException("Unsupported target type", nameof(target));
-			}
-			if (exec != null)
-			{
-				target = new ViewControllerSegueTarget(vc); // clone so we don't risk recreating it
-				if (!await exec.OnBeforeExecute(target))
-					return;
-			}
-
-			// If we don't need a target, or can retrieve it as a Page, route it through classic Forms navigation..
-			Page page = null;
-			if (!action.RequiresTarget() || (page = ViewControllerSegueTarget.GetPage(vc)) != null)
-			{
-				await Element.Navigation.NavigateAsync(action, page, seg.IsAnimated);
-				return;
-			}
-
-			// Otherwise, perform a native transition..
-			switch (action)
-			{
-				case NavigationAction.Show:
-				case NavigationAction.Push:
-					//FIXME: figure out how to await this
-					PushViewController(vc, seg.IsAnimated);
-					return;
-			}
-		}
-
 		void OnRemovedPageRequested(object sender, NavigationRequestedEventArgs e)
 		{
 			RemovePage(e.Page);
@@ -1179,7 +1113,7 @@ public override async void DidMoveToParentViewController(UIViewController parent
 
 		public override UIViewController ChildViewControllerForStatusBarHidden()
 		{
-			return (UIViewController)Platform.GetRenderer(Current);
+			return Platform.GetRenderer(Current).ViewController;
 		}
 
 		void IEffectControlProvider.RegisterEffect(Effect effect)
diff --git a/Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs b/Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs
index d4805098590..cfdf563723f 100644
--- a/Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs
+++ b/Xamarin.Forms.Platform.iOS/Segues/ViewControllerSegueTarget.cs
@@ -8,67 +8,28 @@
 
 namespace Xamarin.Forms
 {
-	public class ViewControllerSegueTarget : SegueTarget
+	public sealed class ViewControllerSegueTarget : SegueTarget
 	{
-		internal static void Init()
-		{
-			SegueTarget.CreateFromObjectHandler = obj => new ViewControllerSegueTarget(obj);
-		}
-
-		public UIViewController ViewController {
-			get {
-				if (IsTemplate)
-					throw new InvalidOperationException("Target is a template");
-				return (UIViewController)TryCreateValue(typeof(UIViewController));
-			}
-		}
+		public UIViewController ViewController { get; }
 
-		protected ViewControllerSegueTarget(object obj) : base(obj)
-		{
-		}
-
-		public ViewControllerSegueTarget(UIViewController viewController)
-			: base (viewController)
+		internal ViewControllerSegueTarget(UIViewController viewController)
 		{
 			if (viewController == null)
 				throw new ArgumentNullException();
+			ViewController = viewController;
 		}
 
-		public override object TryCreateValue(Type targetType)
+		public override Page ToPage()
 		{
-			var result = base.TryCreateValue(targetType);
-			if (result == null)
-			{
-				if (targetType.IsAssignableFrom(typeof(Page)))
-				{
-					var vc = (UIViewController)TryCreateValue(typeof(UIViewController));
-					result = GetPage(vc);
-					if (result == null)
-						Reject(vc);
-				}
-				else if (targetType.IsAssignableFrom(typeof(UIViewController)))
-				{
-					var page = (Page)base.TryCreateValue(typeof(Page));
-					if (page == null)
-						return null;
-
-					var renderer = Platform.iOS.Platform.GetRenderer(page);
-					if (renderer == null)
-					{
-						renderer = Platform.iOS.Platform.CreateRenderer(page);
-						Platform.iOS.Platform.SetRenderer(page, renderer);
-					}
-					return renderer.ViewController;
-				}
-			}
-			return result;
+			return GetPage(ViewController);
 		}
 
-		internal static Page GetPage(UIViewController vc)
+		static Page GetPage(UIViewController vc)
 		{
 			if (vc == null)
 				return null;
-			return ((vc as IVisualElementRenderer)?.Element as Page) ?? GetPage(vc.ChildViewControllers.FirstOrDefault());
+			return (vc as IVisualElementRenderer)?.Element as Page
+			    ?? GetPage(vc.ChildViewControllers.FirstOrDefault());
 		}
 	}
 }
diff --git a/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj b/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
index 52c6b9e8cb2..420d8c53a3e 100644
--- a/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
+++ b/Xamarin.Forms.Platform.iOS/Xamarin.Forms.Platform.iOS.csproj
@@ -140,6 +140,8 @@
     <Compile Include="NativeValueConverterService.cs" />
     <Compile Include="NativeBindingService.cs" />
     <Compile Include="Segues\ViewControllerSegueTarget.cs" />
+    <Compile Include="NativePageWrapper.cs" />
+    <Compile Include="NativePageWrapperRenderer.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources\StringResources.ar.resx" />

From 3e70af0f08c0ba0a255508d87aade0b9feead4b9 Mon Sep 17 00:00:00 2001
From: Alex Corrado <alexc@xamarin.com>
Date: Wed, 16 May 2018 23:14:49 -0400
Subject: [PATCH 5/5] [Segues] Remove SourceElement property

This added extra complexity, but its usefulness wasn't very obvious.

If a good argument were made for having this property, we can revert
this.
---
 Xamarin.Forms.Core/BindableObject.cs | 10 ----------
 Xamarin.Forms.Core/Segues/Segue.cs   | 26 --------------------------
 2 files changed, 36 deletions(-)

diff --git a/Xamarin.Forms.Core/BindableObject.cs b/Xamarin.Forms.Core/BindableObject.cs
index c44aa478c31..21076a59e86 100644
--- a/Xamarin.Forms.Core/BindableObject.cs
+++ b/Xamarin.Forms.Core/BindableObject.cs
@@ -172,16 +172,6 @@ internal bool GetIsBound(BindableProperty targetProperty)
 			return bpcontext != null && bpcontext.Binding != null;
 		}
 
-		internal bool GetIsManuallySet(BindableProperty targetProperty)
-		{
-			if (targetProperty == null)
-				throw new ArgumentNullException(nameof(targetProperty));
-
-			var bpcontext = GetContext(targetProperty);
-			return bpcontext != null
-				&& (bpcontext.Attributes & BindableContextAttributes.IsManuallySet) == BindableContextAttributes.IsManuallySet;
-		}
-
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public object[] GetValues(BindableProperty property0, BindableProperty property1)
 		{
diff --git a/Xamarin.Forms.Core/Segues/Segue.cs b/Xamarin.Forms.Core/Segues/Segue.cs
index 3ef7c46f440..3ff66e2c938 100644
--- a/Xamarin.Forms.Core/Segues/Segue.cs
+++ b/Xamarin.Forms.Core/Segues/Segue.cs
@@ -24,9 +24,6 @@ public class Segue : BindableObject, ISegueExecution
 			BindableProperty.Create(nameof(IsEnabled), typeof(bool), typeof(Segue), defaultValue: true, 
 				propertyChanged: (s, _, __) => ((Segue)s).OnCanExecuteChanged());
 
-		public static readonly BindableProperty SourceElementProperty =
-			BindableProperty.Create(nameof(SourceElement), typeof(Element), typeof(Segue));
-
 		public static readonly BindableProperty TargetProperty =
 			BindableProperty.CreateAttached("Target", typeof(SegueTarget), typeof(Segue), defaultValue: null,
 				propertyChanged: (obj, oldVal, newVal) => {
@@ -60,21 +57,6 @@ public bool IsEnabled {
 			set => SetValue(IsEnabledProperty, value);
 		}
 
-		/// <summary>
-		/// Gets the exact element that triggered this <see cref="Segue"/>, or <c>null</c>
-		///  if one wasn't provided.
-		/// </summary>
-		/// <remarks>
-		/// This property is set automatically when the <c>{Segue}</c> markup extension is used,
-		///  or by the <see cref="ICommand"/> returned by <see cref="ToCommand"/> when the
-		///  <c>source</c> parameter is provided. Setting or binding this property explicitly
-		///  disables that automatic behavior.
-		/// </remarks>
-		public Element SourceElement {
-			get => (Element)GetValue(SourceElementProperty);
-			set => SetValue(SourceElementProperty, value);
-		}
-
 		public event EventHandler<SegueBeforeExecuteEventArgs> BeforeExecute;
 
 		/// <summary>
@@ -158,14 +140,6 @@ internal static Task DefaultExecuteCommand(ValueSegue seg, Element source)
 			if (!seg.IsEnabled)
 				throw new InvalidOperationException("IsEnabled is false");
 
-			var s = seg.Segue;
-			if (s != null)
-			{
-				// Set SourceElement property if it wasn't manually set or bound by the user
-				if (!(s.GetIsBound(SourceElementProperty) || s.GetIsManuallySet(SourceElementProperty)))
-					s.SetValueCore(SourceElementProperty, source);
-			}
-
 			var nav = FindVisualElement(source)?.Navigation;
 			if (nav == null)
 				throw new NotSupportedException("Source must be in the view hierarchy");