Adds Popup Control

[SkyeHoefling]

Description of Change

Adds native popups to iOS/Android/UWP

This PR ports the original popup control implementation from Xamarin.Forms to the Xamarin Community Toolkit. This PR is more complete than the original PR and there is better feature parity between the 3 major platform (iOS/Android/UWP). Please see the table below which documents what features are implemented on each platform.

Feature Add

• Closes [Spec] Popup Control #292
• Related: [Core, iOS, UWP, Android] Popup Control Implementation Xamarin.Forms#9616

API Changes

Added:

• Popup
• Popup<T>
• BasePopup

The popup control allows developers to create popups and they can be extended to return data to the invocation code. This is why there are 3 different classes for XCT Popups. The BasePopup is what is needed at minimum to render a popup on screen. Then Popup<T> allows generic results where Popup will just return an object.

Below documents all the APIs added

BasePopup

View Content { get; set; }
Color Color { get; set; }
LayoutOptions VerticalOptions { get; set; }
LayoutOptions HorizontalOptions { get; set; }
Color BorderColor { get; set; }
View Anchor { get; set; }
Size Size { get; set; }
bool IsLightDissmissEnabled { get; set; }
event EventHandler<PopupDismissedEventArgs> Dismissed;
event EventHandler<PopupOpenedEventArgs> Opened;
void LightDismiss();

Popup

void Reset();
void Dismiss(T result);
Task<T> Result;

Popup

Nothing different than Popup<T> it just uses object as the type definition

Feature Parity Table

This is a very large Pull Request that adds a set of complex features to the 3 major platform (iOS, Android and UWP). It wasn't possible to get perfect feature parity across the platforms and the table below documents what is implemented in each platform

Feature	Android	iOS	UWP
Simple Popup	✅	✅	✅
Light Dismiss (Enabled)	✅	✅	✅
Light Dismiss (Disabled)	✅	✅	❌
Transparent Backgrounds	✅	❌	✅
Custom Background Color	✅	✅	✅
Event - Opened	✅	✅	✅
Event - Dismissed	✅	✅	✅
Layout Positioning	✅	✅	✅
Dynamic Sizing	✅	✅	✅
View Anchoring	✅	✅	✅
Custom Return Object	✅	✅	✅
Custom Light Dismissed Return Object	✅	✅	✅

Usage - Basic

You can use Popups just like you do a ContentView or ContentPage below are some basic examples of using a popup in XAML

<xct:Popup xmlns="http://xamarin.com/schemas/2014/forms"
           xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
           xmlns:xct="clr-namespace:Xamarin.CommunityToolkit.UI.Views;assembly=Xamarin.CommunityToolkit"
           x:Class="MyProject.SimplePopup">

    <StackLayout>
        <Label Text="Hello Simple Popup" />
    </StackLayout>
    
</xct:Popup>

With the popup defined you will display it by using the INavigation extension methods. At the most basic level you can access this on any ContentPage in Xamarin.Forms via the following code

var myPopup = new SimplePopup();
App.Current.MainPaget.Navigation.ShowPopup(myPopup);

Popups can use the event handlers to determine if a popup has opened or been dismissed. The code below will print a message to the console once the popup has been dismissed.

var myPopup = new SimplePopup();
myPopup.Dismissed += (s, e) => Console.WriteLine("Popup Dismissed");
App.Current.MainPage.Navigation.ShowPopup(myPopup);

Popups also support async/await Task. The code below functions the same way as above but without events.

var myPopup = new SimplePopup();
await App.Current.MainPage.Navigation.ShowPopupAsync(myPopup);
Console.WriteLine("Popup Dismissed");

Usage - Return Types

To return an object after dismissing a popup the implementation will need to invoke the Dismiss() method. This will tell the native popup to dismiss and then set the result of the popup with whatever is passed in the parameter. When using a popup with a result it is a good idea to override the GetLightDismissResult() method which is the default value if the user taps outside of the popup to dismiss it.

The solution below is using C# instead of XAML to demonstrate the other technique of creating a Popup

public class ReturnResultPopup : Popup<string>
{
	public ReturnResultPopup()
	{
		Content = new StackLayout
		{
			Children = { Message(), CloseButton() }
		};

		Button CloseButton()
		{
			var button = new Button
			{
				Text = "Close"
			};

			button.Clicked += (s, e) => Dismiss("Close button tapped");
			return button;
		}

		Label Message() =>
			new Label
			{
				Text = "Hello World"
			};
	}

	protected override string GetLightDismissResult() => "Light Dismiss";
}

Once the popup is defined to invoke it you can use the following code which will just print the result in a standard alert

var myPopup = new ReturnResultPopup();
var result = await App.Current.MainPage.Navigation.ShowPopupAsync(myPopup);
await App.Current.MainPage.DisplayAlertAsync("Popup Result", result, "OKAY");

The same technique can also be accomplished using events

var myPopup = new ReturnResultPopup();
myPopup.Dismissed += (s, e) => App.Current.MainPage.DisplayAlertAsync("Popup Result", e.Result, "OKAY");
app.Current.MainPage.Navigation.ShowPopup(myPopup);

Screenshots

Below are a series of screenshots from the sample app that demonstrate some of the different features of the Popup Control. It is not a complete list as some features are difficult to demonstrate in a screenshot.

Simple Popup

Custom Positioning Popup

You can position a popup anywhere on the screen, the screenshot below shows that the popup is positioned horizontally left and vertically center

Transparent Background Popup

As noted in the table above this doesn't work on iOS but it is still useful to see it working across the 3 major platforms

Toggle Size Popup

Anchor Popup

You can anchor a popup over another element

Notes to Code Reviewers

I have left some comments throughout the code that ask questions about certain techniques. I plan to remove those prior to accepting this change but it will be a good opportunity for us to have some dialog. I am going to go through and start discussion points on them so they are easier to find.

PR Checklist

• Has tests (if omitted, state reason in description)
• Has samples (if omitted, state reason in description)
• Rebased on top of main at time of PR
• Changes adhere to coding standard

• Updated documentation

[AndreiMisiukevich]

Can we avoid initializing it somehow?
Maybe we should depend on CrossCurrentActivity plugin? @jfversluis @pictos @jsuarezruiz @sthewissen

[pictos]

CrossCurrentActivity needs to be initialized as well... We still have access to the Forms.Forms.Context is obsolete, but will there until Maui. This on top of my head, after looking at the implementation I can have more (bad) ideas 😋

[pictos]

also...We are using the multi-target structure, we can inspire in how Maui is exposing the native objects in shared code.

[SkyeHoefling]

This is required in the NavigationExtensions.android.cs as it uses Platform.CreateRendererWithContext.

I didn't have a good alternative that I could think of when implementing this. The Popup controls are quite different than standard renderers as it needs to invoke the Platform.CreateRendererWithContext API. Typically this isn't needed as most custom renderers are loaded in the context of a ContentPage.

I looked at using the [Obsolete] API Platform.CreateRenderer for Android but didn't want new code to depend on deprecated APIs. I could see an argument for removing that deprecation flag in Xamarin.Forms 5, but I think that will cause more harm to the general ecosystem since using it with the correct Context is very important.

I'm all ears for a better way to handle this as I don't like having the init API if we can avoid it. To add an additional mind to the mix, @PureWeen do you have any thoughts on this?

[pictos]

@ahoefling when we perform the navigation, we already have the BasePopup instanciated? If so I think that we solve this more easily.

[SkyeHoefling]

Yes, we have an instance of the BasePopup, but there is no renderer associated with it unless we manually instantiate it. This is because the concept of Popups doesn't exist in Xamarin.Forms. I am using the CreateRenderer APIs to manually associate the shared object with it's native renderer.

[pictos]

Well... I want to see if we can resolve this in the renderer area first and if we don't a way move to having an android lifecycle, to track the current Context.

[SkyeHoefling]

I'm really hoping someone will spot a thing I missed. It was very frustrating when I had to use this workaround 😢

[pictos]

@ahoefling thank you for this huge contribution, I didn't run the code on my side, my comments, for now, are just about the code and any comment about implementation is just theoretical. Let me know your thoughts.

[pictos]

Will we have some properties here? If don't I think that we can remove this EventArgs (?)

[SkyeHoefling]

The intent here was to create an event argument that we could build off in the future. Considering that all event arguments should inherit from EventArgs I agree that we should just remove this.

[pictos]

If we will use this, will be better to keep it there, because adding in the future the users will need to go for all delegates and change the EventArgs to PopupOpenedEventArgs .

[pictos]

also...We are using the multi-target structure, we can inspire in how Maui is exposing the native objects in shared code.

[pictos]

Note for reviewers, since this a ported code (basically the maintenance will be copy and paste), I think that is ok to keep the same code style as the original source. If you agree with me, we can suppress the warning in this file.

[pictos]

Wondering if they forgot to unsubscribe from this event... 🤔

[pictos]

Do we need to upgrade this version? I mean is this better than using the WinUI (I remember that we talked about it on the discord channel)?

[SkyeHoefling]

I needed to update to 19041 to get the Flyout to render with a transparent background. Prior to 18362 the Flyout Shadow was not configurable which means there would be a weird shadow if you set the Color to transparent. I am not sure the best way to handle this as I added a pre-processor directive #if to only use the property if the windows version is >= 18362.

PopupRenderer.uwp.cs:168-171

#if UWP_18362
    if (Element.Color == Color.Transparent)
        flyoutStyle.Setters.Add(new Windows.UI.Xaml.Setter(FlyoutPresenter.IsDefaultShadowEnabledProperty, false));
#endif

In the UWP Sample App it is using 18362 as the target but 17763 as the min version. I think this is 'okay' but if anyone knows a better way to manage this I am all ears.

WinUI Investigation

While implementing this I tried using WinUI instead of the UWP library as the Flyout control is available in WinUI 3. Xamarin.Forms Shell takes a dependency on WinUI 2 and Flyout isn't available in WinUI 2. It would create a management nightmare for XCT to include WinUI 3 and Xamarin.Forms to include WinUI 2.

WinUI 3 is still in preview and I don't think it makes sense to do any push for supporting it in Xamarin.Forms 5 at this point. Perhaps once Xamarin.Forms 5 is shipped and WinUI 3 is released we could revisit this idea

[pictos]

Said that, is there a problem to have a mismatch version with the XF or apps made with XF? If don't have any compatibility problem I'm ok with that.
Because I can remember that apps can have a problem with the supported version, see this #624.

[VladislavAntonyuk]

can you adapt it with Tooltip control (http://www.xamboy.com/2019/03/01/showing-tooltips-in-xamarin-forms/)? I see you added Anchor Popup, but looks like on Android it doesn't have arrow and dims the background.

[SkyeHoefling]

@VladislavAntonyuk

can you adapt it with Tooltip control

This is a great idea to support arrows across all the platforms. They were never part of the original spec that EZ wrote a few years ago nor the spec that was ported from the Xamarin.Forms repo to XCT. I believe adding support for arrows is out of scope for the initial PR, but I think it is something we should absolutely add to the backlog.

To properly support arrows and dimming across the platforms we should spike out how that would look for UWP as I think that is the only unknown at this point.

[jsuarezruiz]

@ahoefling Could you rebase to fix the conflicts?. Thanks!.

[jsuarezruiz]

Yes, use the FeatureNotSupportedException https://github.com/xamarin/Essentials/blob/fe78dad8e2b0d78b7ba3ee5460862e1dbb2ed994/Xamarin.Essentials/Types/Shared/Exceptions.shared.cs#L33

[SkyeHoefling]

I just pushed some changes and took care of a good number of the requests in the code review. I didn't get through everything, but marked everything that I have done something for as resolved. Some of the threads I looked at but couldn't get it quite right, so I left some additional comments in those.

If I get more time this weekend I'll try and make another pass.

[SkyeHoefling]

I just made another code push which covers the majority of outstanding feedback items.

@pictos
I had a few questions for you in the review comments, once we get some clarification on those I can make another code push

[pictos]

@ahoefling can you solve these conflicts? I think that will be easy since the changes are just moving folders and files. I'll find a time this weekend to review this and answer your questions.

[SkyeHoefling]

@pictos I updated the WeakEventManager to be a local static so it can be easily accessed between the PopupRenderer and PopupDelegate. Does this solve the Garbage Collection issue we were discussing earlier?

[SkyeHoefling]

I have rebased this PR on the latest changes in main, and made another change to the iOS renderer. I added a single-line comment on a line of code that is important to review.

[pictos]

@ahoefling
The build failed
samples\XCT.Sample\ViewModels\Views\ViewsGalleryViewModel.cs(53,28): Error CS0246: The type or namespace name 'PopupGalleryPage' could not be found (are you missing a using directive or an assembly reference?)

[SkyeHoefling]

Ugh, build failures

👀👀

[SkyeHoefling]

It should be all fixed now

[TheCodeTraveler]

Adding the DO-NOT-MERGE label for now until WeakEventManager is properly implemented

[TheCodeTraveler]

@ahoefling Does PopoverDelegate.DidDismiss need to be implemented?

I'm testing the sample with the following code for PopoverDelegate, and it seems to be functioning properly.

That being said, I'm not an expert on this Popup control 🙂

class PopoverDelegate : UIPopoverPresentationControllerDelegate
{
	public override UIModalPresentationStyle GetAdaptivePresentationStyle(UIPresentationController forPresentationController) =>
		UIModalPresentationStyle.None;
}

---

If we do not need to implement PopoverDelegate.DidDismiss, this is my recommended solution:

• Remove WeakEventManager from PopupRenderer.ios.cs
• Implement WeakEventManager in BasePopup.shared.cs

PopupRenderer.ios.cs

Removes WeakEventManager

using System;
using System.ComponentModel;
using CoreGraphics;
using UIKit;
using Xamarin.CommunityToolkit.UI.Views;
using Xamarin.Forms;
using Xamarin.Forms.Platform.iOS;

[assembly: ExportRenderer(typeof(BasePopup), typeof(PopupRenderer))]

namespace Xamarin.CommunityToolkit.UI.Views
{
	public class PopupRenderer : UIViewController, IVisualElementRenderer
	{
		bool isDisposed;

		public IVisualElementRenderer Control { get; private set; }

		public BasePopup Element { get; private set; }

		VisualElement IVisualElementRenderer.Element => Element;

		public UIView NativeView => base.View;

		public UIViewController ViewController { get; private set; }

		public event EventHandler<VisualElementChangedEventArgs> ElementChanged;

		public event EventHandler<PropertyChangedEventArgs> ElementPropertyChanged;

		public void SetElementSize(Size size) =>
			Control?.SetElementSize(size);

		public override void ViewDidLayoutSubviews()
		{
			base.ViewDidLayoutSubviews();
			SetElementSize(new Size(base.View.Bounds.Width, base.View.Bounds.Height));
		}

		public override void ViewDidAppear(bool animated)
		{
			base.ViewDidAppear(animated);

			ModalInPopover = !Element.IsLightDismissEnabled;
		}

		public SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint) =>
			NativeView.GetSizeRequest(widthConstraint, heightConstraint);

		void IVisualElementRenderer.SetElement(VisualElement element)
		{
			if (element == null)
				throw new ArgumentNullException(nameof(element));

			if (!(element is BasePopup popup))
				throw new ArgumentNullException("Element is not of type " + typeof(BasePopup), nameof(element));

			var oldElement = Element;
			Element = popup;
			CreateControl();

			if (oldElement != null)
				oldElement.PropertyChanged -= OnElementPropertyChanged;

			element.PropertyChanged += OnElementPropertyChanged;

			OnElementChanged(new ElementChangedEventArgs<BasePopup>(oldElement, Element));
		}

		protected virtual void OnElementChanged(ElementChangedEventArgs<BasePopup> e)
		{
			if (e.NewElement != null && !isDisposed)
			{
				ModalInPopover = true;
				ModalPresentationStyle = UIModalPresentationStyle.Popover;

				SetViewController();
				SetPresentationController();
				SetEvents();
				SetSize();
				SetLayout();
				SetBackgroundColor();
				SetView();
				AddToCurrentPageViewController();
			}

			ElementChanged?.Invoke(this, new VisualElementChangedEventArgs(e.OldElement, e.NewElement));
		}

		protected virtual void OnElementPropertyChanged(object sender, PropertyChangedEventArgs args)
		{
			if (args.PropertyName == BasePopup.VerticalOptionsProperty.PropertyName ||
				args.PropertyName == BasePopup.HorizontalOptionsProperty.PropertyName)
			{
				SetLayout();
			}
			else if (args.PropertyName == BasePopup.SizeProperty.PropertyName)
			{
				SetSize();
			}
			else if (args.PropertyName == BasePopup.ColorProperty.PropertyName)
			{
				SetBackgroundColor();
			}

			ElementPropertyChanged?.Invoke(this, args);
		}

		void CreateControl()
		{
			var view = Element.Content;
			var contentPage = new ContentPage { Content = view, Padding = new Thickness(25) };

			Control = Platform.CreateRenderer(contentPage);
			Platform.SetRenderer(contentPage, Control);
			contentPage.Parent = Application.Current.MainPage;
		}

		void SetViewController()
		{
			var currentPageRenderer = Platform.GetRenderer(Application.Current.MainPage);
			ViewController = currentPageRenderer.ViewController;
		}

		void SetEvents() =>
			Element.Dismissed += OnDismissed;

		void SetSize()
		{
			if (!Element.Size.IsZero)
			{
				PreferredContentSize = new CGSize(Element.Size.Width, Element.Size.Height);
			}
		}

		void SetLayout()
		{
			((UIPopoverPresentationController)PresentationController).SourceRect = new CGRect(0, 0, PreferredContentSize.Width, PreferredContentSize.Height);

			if (Element.Anchor == null)
			{
				nfloat originX = 0;
				nfloat originY = 0;

				switch (Element.VerticalOptions.Alignment)
				{
					case LayoutAlignment.End:
						originY = UIScreen.MainScreen.Bounds.Height - PreferredContentSize.Height;
						break;
					case LayoutAlignment.Center:
						originY = (UIScreen.MainScreen.Bounds.Height / 2) - (PreferredContentSize.Height / 2);
						break;
				}

				switch (Element.HorizontalOptions.Alignment)
				{
					case LayoutAlignment.End:
						originX = UIScreen.MainScreen.Bounds.Width;
						break;
					case LayoutAlignment.Center:
						originX = UIScreen.MainScreen.Bounds.Width / 2;
						break;
				}

				PopoverPresentationController.SourceRect = new CGRect(originX, originY, 0, 0);
			}
			else
			{
				var view = Platform.GetRenderer(Element.Anchor).NativeView;
				PopoverPresentationController.SourceView = view;
				PopoverPresentationController.SourceRect = view.Bounds;
			}
		}

		void SetBackgroundColor() =>
			Control.NativeView.BackgroundColor = Element.Color.ToUIColor();

		void SetView()
		{
			base.View.AddSubview(Control.ViewController.View);
			base.View.Bounds = new CGRect(0, 0, PreferredContentSize.Width, PreferredContentSize.Height);
			AddChildViewController(Control.ViewController);
		}

		void SetPresentationController()
		{
			((UIPopoverPresentationController)PresentationController).SourceView = ViewController.View;

			// Setting PermittedArrowDirector to 0 breaks the Popover layout. It would be nice if there is no anchor to remove the arrow.
			((UIPopoverPresentationController)PresentationController).PermittedArrowDirections = UIPopoverArrowDirection.Up;
			((UIPopoverPresentationController)PresentationController).Delegate = new PopoverDelegate();
		}

		void AddToCurrentPageViewController() =>
			ViewController.PresentViewController(this, true, () => Element.OnOpened());

		void OnDismissed(object sender, PopupDismissedEventArgs e) =>
			ViewController.DismissViewControllerAsync(true);

		protected override void Dispose(bool disposing)
		{
			if (isDisposed)
				return;

			isDisposed = true;
			if (disposing)
			{
				if (Element != null)
				{
					Element.PropertyChanged -= OnElementPropertyChanged;

					if (Platform.GetRenderer(Element) == this)
					{
						// NOTE - AH 9/12/2020
						// This used to use the internal property
						// 'Xamarin.Forms.Platform.iOS.Platform.RendererProperty'
						// That property is marked internal so the closest thing we can do
						// is duplicate the implementation here.
						//
						// I don't think this is really needed for the control, but I am
						// leaving it in so it can be reviewed.
						var rendererProperty = BindableProperty.CreateAttached("Renderer", typeof(IVisualElementRenderer), typeof(Platform), default(IVisualElementRenderer), propertyChanged: (bindable, oldvalue, newvalue) =>
						{
							var view = bindable as VisualElement;
							if (view != null)
								view.IsPlatformEnabled = newvalue != null;
						});

						Element.ClearValue(rendererProperty);
					}

					Element = null;
				}
			}

			base.Dispose(disposing);
		}

		void OnDismiss(object sender, EventArgs e)
		{
			if (IsViewLoaded && Element.IsLightDismissEnabled)
				Element.LightDismiss();
		}

		class PopoverDelegate : UIPopoverPresentationControllerDelegate
		{
			public override UIModalPresentationStyle GetAdaptivePresentationStyle(UIPresentationController forPresentationController) =>
				UIModalPresentationStyle.None;
		}
	}
}

BasePopup.shared.cs

Implements WeakEventManager

using System;
using Xamarin.CommunityToolkit.Helpers;
using Xamarin.Forms;

namespace Xamarin.CommunityToolkit.UI.Views
{
	/// <summary>
	/// The popup controls base implementation.
	/// </summary>
	[ContentProperty(nameof(Content))]
	public abstract class BasePopup : VisualElement
	{
		readonly WeakEventManager<PopupDismissedEventArgs> dismissWeakEventManager = new WeakEventManager<PopupDismissedEventArgs>();
		readonly WeakEventManager<PopupOpenedEventArgs> openedWeakEventManager = new WeakEventManager<PopupOpenedEventArgs>();

		/// <summary>
		/// Instantiates a new instance of <see cref="BasePopup"/>.
		/// </summary>
		public BasePopup()
		{
			Color = Color.White;
			VerticalOptions = LayoutOptions.CenterAndExpand;
			HorizontalOptions = LayoutOptions.CenterAndExpand;
			IsLightDismissEnabled = true;
		}

		public static BindableProperty ColorProperty = BindableProperty.Create(nameof(Color), typeof(Color), typeof(BasePopup));
		public static BindableProperty SizeProperty = BindableProperty.Create(nameof(Size), typeof(Size), typeof(BasePopup));

		public static BindableProperty VerticalOptionsProperty = BindableProperty.Create(nameof(VerticalOptions), typeof(LayoutOptions), typeof(BasePopup), LayoutOptions.CenterAndExpand);
		public static BindableProperty HorizontalOptionsProperty = BindableProperty.Create(nameof(HorizontalOptions), typeof(LayoutOptions), typeof(BasePopup), LayoutOptions.CenterAndExpand);

		/// <summary>
		/// Gets or sets the <see cref="View"/> content to render in the Popup.
		/// </summary>
		/// <remarks>
		/// The View can be or type: <see cref="View"/>, <see cref="ContentPage"/> or <see cref="NavigationPage"/>
		/// </remarks>
		public virtual View Content { get; set; }

		/// <summary>
		/// Gets or sets the <see cref="Color"/> of the Popup.
		/// </summary>
		/// <remarks>
		/// This color sets the native background color of the <see cref="Popup"/>, which is
		/// independent of any background color configured in the actual View.
		/// </remarks>
		public Color Color
		{
			get => (Color)GetValue(ColorProperty);
			set => SetValue(ColorProperty, value);
		}

		/// <summary>
		/// Gets or sets the <see cref="LayoutOptions"/> for positioning the <see cref="Popup"/> vertically on the screen.
		/// </summary>
		public LayoutOptions VerticalOptions
		{
			get => (LayoutOptions)GetValue(VerticalOptionsProperty);
			set => SetValue(VerticalOptionsProperty, value);
		}

		/// <summary>
		/// Gets or sets the <see cref="LayoutOptions"/> for positioning the <see cref="Popup"/> horizontally on the screen.
		/// </summary>
		public LayoutOptions HorizontalOptions
		{
			get => (LayoutOptions)GetValue(HorizontalOptionsProperty);
			set => SetValue(HorizontalOptionsProperty, value);
		}

		/// <summary>
		/// Gets or sets the <see cref="View"/> anchor.
		/// </summary>
		/// <remarks>
		/// The Anchor is where the Popup will render closest to. When an Anchor is configured
		/// the popup will appear centered over that control or as close as possible.
		/// </remarks>
		public View Anchor { get; set; }

		/// <summary>
		/// Gets or sets the <see cref="Size"/> of the Popup Display. 
		/// </summary>
		/// <remarks>
		/// The Popup will always try to constrain the actual size of the <see cref="Popup" />
		/// to the <see cref="Popup" /> of the View unless a <see cref="Size"/> is specified.
		/// If the <see cref="Popup" /> contiains <see cref="LayoutOptions"/> a <see cref="Size"/>
		/// will be required. This will allow the View to have a concept of <see cref="Size"/>
		/// that varies from the actual <see cref="Size"/> of the <see cref="Popup" />
		/// </remarks>
		public Size Size
		{
			get => (Size)GetValue(SizeProperty);
			set => SetValue(SizeProperty, value);
		}

		/// <summary>
		/// Gets or sets a value indicating whether the popup can be light dismissed.
		/// </summary>
		/// <remarks>
		/// When true and the user taps outside of the popup it will dismiss.
		/// </remarks>
		public bool IsLightDismissEnabled { get; set; }

		/// <summary>
		/// Dismissed event is invoked when the popup is closed.
		/// </summary>
		public event EventHandler<PopupDismissedEventArgs> Dismissed
		{
			add => dismissWeakEventManager.AddEventHandler(value);
			remove => dismissWeakEventManager.RemoveEventHandler(value);
		}

		/// <summary>
		/// Opened event is invoked when the popup is opened.
		/// </summary>
		public event EventHandler<PopupOpenedEventArgs> Opened
		{
			add => openedWeakEventManager.AddEventHandler(value);
			remove => openedWeakEventManager.RemoveEventHandler(value);
		}

		/// <summary>
		/// Invokes the <see cref="Dismissed"/> event.
		/// </summary>
		/// <param name="result">
		/// The results to add to the <see cref="PopupDismissedEventArgs"/>.
		/// </param>
		internal void OnDismissed(object result) => dismissWeakEventManager.RaiseEvent(this, new PopupDismissedEventArgs(result), nameof(Dismissed));

		/// <summary>
		/// Invokes the <see cref="Opened"/> event.
		/// </summary>
		internal virtual void OnOpened() => openedWeakEventManager.RaiseEvent(this, new PopupOpenedEventArgs(), nameof(Opened));

		/// <summary>
		/// Invoked when the popup is light dismissed. In other words when the
		/// user taps outside of the popup and it closes.
		/// </summary>
		public virtual void LightDismiss()
		{
			// REVIEW - AH 12/3/2020
			// Should this API be protected internal? It is not intended
			// to be called outside of XCT, but it should allow for subclassing.

			// TODO - AH 12/3/2020
			// This is not being tested correctly. It is not
			// implemented in iOS or UWP.

			// empty default implementation
		}

		/// <inheritdoc />
		protected override void OnBindingContextChanged()
		{
			base.OnBindingContextChanged();

			if (Content != null)
			{
				SetInheritedBindingContext(Content, BindingContext);
			}
		}
	}
}

[SkyeHoefling]

@brminnick thank you for such a detail review on the iOS implementation ❤, this was the hardest implementation for me and it is appreciated. I wasn't 100% sure how we implemented the WeakEventManager, the updates you shared are going to be very useful in my next code push.

The PopoverDelegate is being used to trigger the shared code that a light dismiss has occurred. It invokes the Element.LightDismiss method. You can see this in the code snippet below, which is the OnDismiss method. Understandable this is confusing as there are other method names that are similar.

void OnDismiss(object sender, EventArgs e)
{
    if (IsViewLoaded && Element.IsLightDismissEnabled)
        Element.LightDismiss();
}

I am going to take a much closer look at this. If I can remove the Popover Delegate, I am more than happy to do that. If not I'll provide notes on my findings

[SkyeHoefling]

I just pushed a change that updates the BasePopup to use WeakEventManager. I still need to look at the iOS Popover. There also seems to be some business rule issues with Dismiss vs Light Dismiss that I will look at when I look at the iOS Popover Delegate

[SkyeHoefling]

@brminnick I just took a look at the changes you made, everything looks good to me 👍. Thanks for cleaning up the code.

[jfversluis]

IM DOING THIS

[Suplanus]

This should also works on macOS. The only dependencies are:

• CoreGraphics
• UIKit

[acaliaro]

IM DOING THIS

@jfversluis when will be in the nighlty feed?

[jfversluis]

@acaliaro It already is

[acaliaro]

BasePopup?

[acaliaro]

@acaliaro It already is

how can I visualize it?

await Navigation.ShowPopupAsync(new PopupPezziPrelevatiView()) ;

I see this in the sample, but what is "Navigation"?

[Cfun1]

@acaliaro It already is

how can I visualize it?

await Navigation.ShowPopupAsync(new PopupPezziPrelevatiView()) ;

I see this in the sample, but what is "Navigation"?

@acaliaro check

XamarinCommunityToolkit/samples/XCT.Sample/ViewModels/Views/PopupControlViewModel.cs

Line 14 in 3f7bc8c

INavigation Navigation => App.Current.MainPage.Navigation;

[acaliaro]

Is it possible that the popup takes up as little space as possible, depending on its content? There appears to be a "Size" parameter which however defines a static size. Rg.Popup adapts to the content by defining HorizontalOptions and VerticalOptions; Can the XCT popup do the same?