// (c) Copyright Microsoft Corporation.
// This source is subject to the Microsoft Public License (Ms-PL).
// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
// All other rights reserved.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
#if WINDOWS_PHONE
using Microsoft.Phone.Controls.Primitives;
using Microsoft.Phone.Controls;
using Microsoft.Phone.Shell;
#endif

#if WINDOWS_PHONE
namespace Microsoft.Phone.Controls
#else
namespace System.Windows.Controls
#endif
{
    /// <summary>
    /// Represents a pop-up menu that enables a control to expose functionality that is specific to the context of the control.
    /// </summary>
    /// <QualityBand>Preview</QualityBand>
#if WINDOWS_PHONE
    [TemplateVisualState(GroupName = VisibilityGroupName, Name = OpenVisibilityStateName)]
    [TemplateVisualState(GroupName = VisibilityGroupName, Name = ClosedVisibilityStateName)]
    [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Code flow is reasonably clear.")]
#endif
    public class ContextMenu : MenuBase
    {
#if WINDOWS_PHONE
        /// <summary>
        /// Visibility state group.
        /// </summary>
        private const string VisibilityGroupName = "VisibilityStates";

        /// <summary>
        /// Open visibility state.
        /// </summary>
        private const string OpenVisibilityStateName = "Open";

        /// <summary>
        /// Closed visibility state.
        /// </summary>
        private const string ClosedVisibilityStateName = "Closed";

        /// <summary>
        /// Stores a reference to the PhoneApplicationPage that contains the owning object.
        /// </summary>
        private PhoneApplicationPage _page;

        /// <summary>
        /// Stores a reference to a list of ApplicationBarIconButtons for which the Click event is being handled.
        /// </summary>
        private readonly List<ApplicationBarIconButton> _applicationBarIconButtons = new List<ApplicationBarIconButton>();

        /// <summary>
        /// Stores a reference to the Storyboard used to animate the background resize.
        /// </summary>
        private Storyboard _backgroundResizeStoryboard;

        /// <summary>
        /// Stores a reference to the Storyboard used to animate the ContextMenu open.
        /// </summary>
        private Storyboard _openingStoryboard;

        /// <summary>
        /// Tracks whether the Storyboard used to animate the ContextMenu open is active.
        /// </summary>
        private bool _openingStoryboardPlaying;

        /// <summary>
        /// Tracks the threshold for releasing contact during the ContextMenu open animation.
        /// </summary>
        private DateTime _openingStoryboardReleaseThreshold;
#endif

        /// <summary>
        /// Stores a reference to the current root visual.
        /// </summary>
#if WINDOWS_PHONE
        private PhoneApplicationFrame _rootVisual;
#else
        private FrameworkElement _rootVisual;
#endif

        /// <summary>
        /// Stores the last known mouse position (via MouseMove).
        /// </summary>
        private Point _mousePosition;

        /// <summary>
        /// Stores a reference to the object that owns the ContextMenu.
        /// </summary>
        private DependencyObject _owner;

        /// <summary>
        /// Stores a reference to the current Popup.
        /// </summary>
        private Popup _popup;

        /// <summary>
        /// Stores a reference to the current overlay.
        /// </summary>
        private Panel _overlay;

        /// <summary>
        /// Stores a reference to the current Popup alignment point.
        /// </summary>
        private Point _popupAlignmentPoint;

        /// <summary>
        /// Stores a value indicating whether the IsOpen property is being updated by ContextMenu.
        /// </summary>
        private bool _settingIsOpen;

        /// <summary>
        /// Gets or sets the owning object for the ContextMenu.
        /// </summary>
        internal DependencyObject Owner
        {
            get { return _owner; }
            set
            {
                if (null != _owner)
                {
                    FrameworkElement ownerFrameworkElement = _owner as FrameworkElement;
                    if (null != ownerFrameworkElement)
                    {
#if WINDOWS_PHONE
                        GestureListener listener = GestureService.GetGestureListener(ownerFrameworkElement);
                        listener.Hold -= new EventHandler<GestureEventArgs>(HandleOwnerHold);
                        ownerFrameworkElement.Loaded -= new RoutedEventHandler(HandleOwnerLoaded);
                        ownerFrameworkElement.Unloaded -= new RoutedEventHandler(HandleOwnerUnloaded);
                        HandleOwnerUnloaded(null, null);
#else
                        ownerFrameworkElement.MouseRightButtonDown -= new MouseButtonEventHandler(HandleOwnerMouseRightButtonDown);
#endif
                    }
                }
                _owner = value;
                if (null != _owner)
                {
                    FrameworkElement ownerFrameworkElement = _owner as FrameworkElement;
                    if (null != ownerFrameworkElement)
                    {
#if WINDOWS_PHONE
                        GestureListener listener = GestureService.GetGestureListener(ownerFrameworkElement);
                        listener.Hold += new EventHandler<GestureEventArgs>(HandleOwnerHold);
                        ownerFrameworkElement.Loaded += new RoutedEventHandler(HandleOwnerLoaded);
                        ownerFrameworkElement.Unloaded += new RoutedEventHandler(HandleOwnerUnloaded);
                        // Owner *may* already be live and have fired its Loaded event - hook up manually if necessary
                        DependencyObject parent = ownerFrameworkElement;
                        while (parent != null)
                        {
                            parent = VisualTreeHelper.GetParent(parent);
                            if ((null != parent) && (parent == _rootVisual))
                            {
                                HandleOwnerLoaded(null, null);
                                break;
                            }
                        }
#else
                        ownerFrameworkElement.MouseRightButtonDown += new MouseButtonEventHandler(HandleOwnerMouseRightButtonDown);
#endif
                    }
                }
            }
        }

#if WINDOWS_PHONE
        /// <summary>
        /// Gets or sets a value indicating whether the background will zoom out when the ContextMenu is open.
        /// </summary>
        public bool IsZoomEnabled
        {
            get { return (bool)GetValue(IsZoomEnabledProperty); }
            set { SetValue(IsZoomEnabledProperty, value); }
        }

        /// <summary>
        /// Identifies the IsZoomEnabled dependency property.
        /// </summary>
        public static readonly DependencyProperty IsZoomEnabledProperty = DependencyProperty.Register(
            "IsZoomEnabled",
            typeof(bool),
            typeof(ContextMenu),
            new PropertyMetadata(true));
#else
        /// <summary>
        /// Gets or sets the horizontal distance between the target origin and the popup alignment point.
        /// </summary>
        [TypeConverterAttribute(typeof(LengthConverter))]
        public double HorizontalOffset
        {
            get { return (double)GetValue(HorizontalOffsetProperty); }
            set { SetValue(HorizontalOffsetProperty, value); }
        }

        /// <summary>
        /// Identifies the HorizontalOffset dependency property.
        /// </summary>
        public static readonly DependencyProperty HorizontalOffsetProperty = DependencyProperty.Register(
            "HorizontalOffset",
            typeof(double),
            typeof(ContextMenu),
            new PropertyMetadata(0.0, OnHorizontalVerticalOffsetChanged));
#endif

        /// <summary>
        /// Gets or sets the vertical distance between the target origin and the popup alignment point.
        /// </summary>
        [TypeConverterAttribute(typeof(LengthConverter))]
        public double VerticalOffset
        {
            get { return (double)GetValue(VerticalOffsetProperty); }
            set { SetValue(VerticalOffsetProperty, value); }
        }

        /// <summary>
        /// Identifies the VerticalOffset dependency property.
        /// </summary>
        public static readonly DependencyProperty VerticalOffsetProperty = DependencyProperty.Register(
            "VerticalOffset",
            typeof(double),
            typeof(ContextMenu),
            new PropertyMetadata(0.0, OnHorizontalVerticalOffsetChanged));

        /// <summary>
        /// Handles changes to the HorizontalOffset or VerticalOffset DependencyProperty.
        /// </summary>
        /// <param name="o">DependencyObject that changed.</param>
        /// <param name="e">Event data for the DependencyPropertyChangedEvent.</param>
        private static void OnHorizontalVerticalOffsetChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            ((ContextMenu)o).UpdateContextMenuPlacement();
        }

        /// <summary>
        /// Gets or sets a value indicating whether the ContextMenu is visible.
        /// </summary>
        public bool IsOpen
        {
            get { return (bool)GetValue(IsOpenProperty); }
            set { SetValue(IsOpenProperty, value); }
        }

        /// <summary>
        /// Identifies the IsOpen dependency property.
        /// </summary>
        public static readonly DependencyProperty IsOpenProperty = DependencyProperty.Register(
            "IsOpen",
            typeof(bool),
            typeof(ContextMenu),
            new PropertyMetadata(false, OnIsOpenChanged));

        /// <summary>
        /// Handles changes to the IsOpen DependencyProperty.
        /// </summary>
        /// <param name="o">DependencyObject that changed.</param>
        /// <param name="e">Event data for the DependencyPropertyChangedEvent.</param>
        private static void OnIsOpenChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            ((ContextMenu)o).OnIsOpenChanged(/*(bool)e.OldValue,*/ (bool)e.NewValue);
        }

        /// <summary>
        /// Handles changes to the IsOpen property.
        /// </summary>
        /// <param name="newValue">New value.</param>
        private void OnIsOpenChanged(/*bool oldValue,*/ bool newValue)
        {
            if (!_settingIsOpen)
            {
                if (newValue)
                {
                    OpenPopup(_mousePosition);
                }
                else
                {
                    ClosePopup();
                }
            }
        }

        /// <summary>
        /// Occurs when a particular instance of a ContextMenu opens.
        /// </summary>
        public event RoutedEventHandler Opened;

        /// <summary>
        /// Called when the Opened event occurs.
        /// </summary>
        /// <param name="e">Event arguments.</param>
        protected virtual void OnOpened(RoutedEventArgs e)
        {
#if WINDOWS_PHONE
            GoToVisualState(OpenVisibilityStateName, true);
#endif
            RoutedEventHandler handler = Opened;
            if (null != handler)
            {
                handler.Invoke(this, e);
            }
        }

        /// <summary>
        /// Occurs when a particular instance of a ContextMenu closes.
        /// </summary>
        public event RoutedEventHandler Closed;

        /// <summary>
        /// Called when the Closed event occurs.
        /// </summary>
        /// <param name="e">Event arguments.</param>
        protected virtual void OnClosed(RoutedEventArgs e)
        {
#if WINDOWS_PHONE
            GoToVisualState(ClosedVisibilityStateName, true);
#endif
            RoutedEventHandler handler = Closed;
            if (null != handler)
            {
                handler.Invoke(this, e);
            }
        }

        /// <summary>
        /// Initializes a new instance of the ContextMenu class.
        /// </summary>
        public ContextMenu()
        {
            DefaultStyleKey = typeof(ContextMenu);

            // Temporarily hook LayoutUpdated to find out when Application.Current.RootVisual gets set.
            LayoutUpdated += new EventHandler(HandleLayoutUpdated);
        }

#if WINDOWS_PHONE
        /// <summary>
        /// Called when a new Template is applied.
        /// </summary>
        public override void OnApplyTemplate()
        {
            // Unhook from old Template
            if (null != _openingStoryboard)
            {
                _openingStoryboard.Completed -= new EventHandler(HandleStoryboardCompleted);
                _openingStoryboard = null;
            }
            _openingStoryboardPlaying = false;

            // Apply new template
            base.OnApplyTemplate();

            // Hook up to new template
            FrameworkElement templateRoot = VisualTreeHelper.GetChild(this, 0) as FrameworkElement;
            if (null != templateRoot)
            {
                foreach (VisualStateGroup group in VisualStateManager.GetVisualStateGroups(templateRoot))
                {
                    if (VisibilityGroupName == group.Name)
                    {
                        foreach (VisualState state in group.States)
                        {
                            if ((OpenVisibilityStateName == state.Name) && (null != state.Storyboard))
                            {
                                _openingStoryboard = state.Storyboard;
                                _openingStoryboard.Completed += new EventHandler(HandleStoryboardCompleted);
                            }
                        }
                    }
                }
            }

            // Go to correct visual state(s)
            GoToVisualState(ClosedVisibilityStateName, false);
            if (IsOpen)
            {
                // Handles initial open (where OnOpened is called before OnApplyTemplate)
                GoToVisualState(OpenVisibilityStateName, true);
            }
        }

        /// <summary>
        /// Handles the Completed event of the opening Storyboard.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleStoryboardCompleted(object sender, EventArgs e)
        {
            _openingStoryboardPlaying = false;
        }

        /// <summary>
        /// Uses VisualStateManager to go to a new visual state.
        /// </summary>
        /// <param name="stateName">The state to transition to.</param>
        /// <param name="useTransitions">true to use a System.Windows.VisualTransition to transition between states; otherwise, false.</param>
        private void GoToVisualState(string stateName, bool useTransitions)
        {
            if ((OpenVisibilityStateName == stateName) && (null != _openingStoryboard))
            {
                _openingStoryboardPlaying = true;
                _openingStoryboardReleaseThreshold = DateTime.UtcNow.AddSeconds(0.3);
            }
            VisualStateManager.GoToState(this, stateName, useTransitions);
        }
#endif

        /// <summary>
        /// Called when the left mouse button is pressed.
        /// </summary>
        /// <param name="e">The event data for the MouseLeftButtonDown event.</param>
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
        {
            if (e == null)
            {
                throw new ArgumentNullException("e");
            }

            e.Handled = true;
            base.OnMouseLeftButtonDown(e);
        }

#if !WINDOWS_PHONE
        /// <summary>
        /// Called when the right mouse button is pressed.
        /// </summary>
        /// <param name="e">The event data for the MouseRightButtonDown event.</param>
        protected override void OnMouseRightButtonDown(MouseButtonEventArgs e)
        {
            e.Handled = true;
            base.OnMouseRightButtonDown(e);
        }
#endif

        /// <summary>
        /// Responds to the KeyDown event.
        /// </summary>
        /// <param name="e">The event data for the KeyDown event.</param>
        protected override void OnKeyDown(KeyEventArgs e)
        {
            if (e == null)
            {
                throw new ArgumentNullException("e");
            }

            switch (e.Key)
            {
                case Key.Up:
                    FocusNextItem(false);
                    e.Handled = true;
                    break;
                case Key.Down:
                    FocusNextItem(true);
                    e.Handled = true;
                    break;
                case Key.Escape:
                    ClosePopup();
                    e.Handled = true;
                    break;
                // case Key.Apps: // Key.Apps not defined by Silverlight 4
            }
            base.OnKeyDown(e);
        }

        /// <summary>
        /// Handles the LayoutUpdated event to capture Application.Current.RootVisual.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleLayoutUpdated(object sender, EventArgs e)
        {
            if (null != Application.Current.RootVisual)
            {
                // Application.Current.RootVisual is valid now
                InitializeRootVisual();
                // Unhook event
                LayoutUpdated -= new EventHandler(HandleLayoutUpdated);
            }
        }

        /// <summary>
        /// Handles the RootVisual's MouseMove event to track the last mouse position.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleRootVisualMouseMove(object sender, MouseEventArgs e)
        {
            _mousePosition = e.GetPosition(null);
        }

#if WINDOWS_PHONE
        /// <summary>
        /// Handles the ManipulationCompleted event for the RootVisual.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleRootVisualManipulationCompleted(object sender, ManipulationCompletedEventArgs e)
        {
            // Breaking contact during the ContextMenu show animation should cancel the ContextMenu
            if (_openingStoryboardPlaying && (DateTime.UtcNow <= _openingStoryboardReleaseThreshold))
            {
                IsOpen = false;
            }
        }

        /// <summary>
        /// Handles the Hold event for the owning element.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleOwnerHold(object sender, GestureEventArgs e)
#else
        /// <summary>
        /// Handles the MouseRightButtonDown event for the owning element.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleOwnerMouseRightButtonDown(object sender, MouseButtonEventArgs e)
#endif
        {
            if (!IsOpen)
            {
                OpenPopup(e.GetPosition(null));
                e.Handled = true;
            }
        }

#if WINDOWS_PHONE
        /// <summary>
        /// Identifies the ApplicationBarMirror dependency property.
        /// </summary>
        private static readonly DependencyProperty ApplicationBarMirrorProperty = DependencyProperty.Register(
            "ApplicationBarMirror",
            typeof(IApplicationBar),
            typeof(ContextMenu),
            new PropertyMetadata(OnApplicationBarMirrorChanged));

        /// <summary>
        /// Handles changes to the ApplicationBarMirror DependencyProperty.
        /// </summary>
        /// <param name="o">DependencyObject that changed.</param>
        /// <param name="e">Event data for the DependencyPropertyChangedEvent.</param>
        private static void OnApplicationBarMirrorChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            ((ContextMenu)o).OnApplicationBarMirrorChanged((IApplicationBar)e.OldValue, (IApplicationBar)e.NewValue);
        }

        /// <summary>
        /// Handles changes to the ApplicationBarMirror property.
        /// </summary>
        /// <param name="oldValue">Old value.</param>
        /// <param name="newValue">New value.</param>
        private void OnApplicationBarMirrorChanged(IApplicationBar oldValue, IApplicationBar newValue)
        {
            if (null != oldValue)
            {
                oldValue.StateChanged -= new EventHandler<ApplicationBarStateChangedEventArgs>(HandleEventThatClosesContextMenu);
            }
            if (null != newValue)
            {
                newValue.StateChanged += new EventHandler<ApplicationBarStateChangedEventArgs>(HandleEventThatClosesContextMenu);
            }
        }

        /// <summary>
        /// Handles an event which should close an open ContextMenu.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleEventThatClosesContextMenu(object sender, EventArgs e)
        {
            // Close the ContextMenu because the elements and/or layout is likely to have changed significantly
            IsOpen = false;
        }

        /// <summary>
        /// Handles the Loaded event of the Owner.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleOwnerLoaded(object sender, RoutedEventArgs e)
        {
            if (null == _page) // Don't want to attach to BackKeyPress twice
            {
                InitializeRootVisual();
                if (null != _rootVisual)
                {
                    _page = _rootVisual.Content as PhoneApplicationPage;
                    if (_page != null)
                    {
                        _page.BackKeyPress += new EventHandler<CancelEventArgs>(HandlePageBackKeyPress);
                        SetBinding(ApplicationBarMirrorProperty, new Binding { Source = _page, Path = new PropertyPath("ApplicationBar") });
                    }
                }
            }
        }

        /// <summary>
        /// Handles the Unloaded event of the Owner.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleOwnerUnloaded(object sender, RoutedEventArgs e)
        {
            if (_page != null)
            {
                _page.BackKeyPress -= new EventHandler<CancelEventArgs>(HandlePageBackKeyPress);
                ClearValue(ApplicationBarMirrorProperty);
                _page = null;
            }
        }

        /// <summary>
        /// Handles the BackKeyPress of the containing PhoneApplicationPage.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandlePageBackKeyPress(object sender, CancelEventArgs e)
        {
            if (IsOpen)
            {
                IsOpen = false;
                e.Cancel = true;
            }
        }

        /// <summary>
        /// Calls TransformToVisual on the specified element for the specified visual, suppressing the ArgumentException that can occur in some cases.
        /// </summary>
        /// <param name="element">Element on which to call TransformToVisual.</param>
        /// <param name="visual">Visual to pass to the call to TransformToVisual.</param>
        /// <returns>Resulting GeneralTransform object.</returns>
        private static GeneralTransform SafeTransformToVisual(UIElement element, UIElement visual)
        {
            GeneralTransform result;
            try
            {
                result = element.TransformToVisual(visual);
            }
            catch (ArgumentException)
            {
                // Not perfect, but better than throwing an exception
                result = new TranslateTransform();
            }
            return result;
        }
#endif

        /// <summary>
        /// Initialize the _rootVisual property (if possible and not already done).
        /// </summary>
        private void InitializeRootVisual()
        {
            if (null == _rootVisual)
            {
                // Try to capture the Application's RootVisual
                _rootVisual = Application.Current.RootVisual as
#if WINDOWS_PHONE
                    PhoneApplicationFrame;
#else
                    FrameworkElement;
#endif
                if (null != _rootVisual)
                {
                    // Ideally, this would use AddHandler(MouseMoveEvent), but MouseMoveEvent doesn't exist
                    _rootVisual.MouseMove += new MouseEventHandler(HandleRootVisualMouseMove);

#if WINDOWS_PHONE
                    _rootVisual.ManipulationCompleted += new EventHandler<ManipulationCompletedEventArgs>(HandleRootVisualManipulationCompleted);
                    _rootVisual.OrientationChanged += new EventHandler<OrientationChangedEventArgs>(HandleEventThatClosesContextMenu);
#endif
                }
            }
        }

        /// <summary>
        /// Sets focus to the next item in the ContextMenu.
        /// </summary>
        /// <param name="down">True to move the focus down; false to move it up.</param>
        private void FocusNextItem(bool down)
        {
            int count = Items.Count;
            int startingIndex = down ? -1 : count;
            MenuItem focusedMenuItem = FocusManager.GetFocusedElement() as MenuItem;
            if (null != focusedMenuItem && (this == focusedMenuItem.ParentMenuBase))
            {
                startingIndex = ItemContainerGenerator.IndexFromContainer(focusedMenuItem);
            }
            int index = startingIndex;
            do
            {
                index = (index + count + (down ? 1 : -1)) % count;
                MenuItem container = ItemContainerGenerator.ContainerFromIndex(index) as MenuItem;
                if (null != container)
                {
                    if (container.IsEnabled && container.Focus())
                    {
                        break;
                    }
                }
            }
            while (index != startingIndex);
        }

        /// <summary>
        /// Called when a child MenuItem is clicked.
        /// </summary>
        internal void ChildMenuItemClicked()
        {
            ClosePopup();
        }

        /// <summary>
        /// Handles the SizeChanged event for the ContextMenu or RootVisual.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleContextMenuOrRootVisualSizeChanged(object sender, SizeChangedEventArgs e)
        {
            UpdateContextMenuPlacement();
        }

        /// <summary>
        /// Handles the MouseButtonDown events for the overlay.
        /// </summary>
        /// <param name="sender">Source of the event.</param>
        /// <param name="e">Event arguments.</param>
        private void HandleOverlayMouseButtonDown(object sender, MouseButtonEventArgs e)
        {
            ClosePopup();
            e.Handled = true;
        }

        /// <summary>
        /// Updates the location and size of the Popup and overlay.
        /// </summary>
        private void UpdateContextMenuPlacement()
        {
            if ((null != _rootVisual) && (null != _overlay))
            {
                // Start with the current Popup alignment point
                double x = _popupAlignmentPoint.X;
                double y = _popupAlignmentPoint.Y;
                // Adjust for offset
#if !WINDOWS_PHONE
                x += HorizontalOffset;
#endif
                y += VerticalOffset;
#if WINDOWS_PHONE
                // Determine frame/page bounds
                bool portrait = (_rootVisual.Orientation & PageOrientation.Portrait) == PageOrientation.Portrait;
                double effectiveWidth = portrait ? _rootVisual.ActualWidth : _rootVisual.ActualHeight;
                double effectiveHeight = portrait ? _rootVisual.ActualHeight : _rootVisual.ActualWidth;
                Rect bounds = new Rect(0, 0, effectiveWidth, effectiveHeight);
                if (_page != null)
                {
                    bounds = SafeTransformToVisual(_page, _rootVisual).TransformBounds(new Rect(0, 0, _page.ActualWidth, _page.ActualHeight));
                }
                // Left align with full width
                x = bounds.Left;
                Width = bounds.Width;
                // Ensure the bottom is visible / ensure the top is visible
                y = Math.Min(y, bounds.Bottom - ActualHeight);
                y = Math.Max(y, bounds.Top);
#else
                // Try not to let it stick out too far to the right/bottom
                x = Math.Min(x, _rootVisual.ActualWidth - ActualWidth);
                y = Math.Min(y, _rootVisual.ActualHeight - ActualHeight);
#endif
                // Do not let it stick out too far to the left/top
                x = Math.Max(x, 0);
                y = Math.Max(y, 0);
                // Set the new location
                Canvas.SetLeft(this, x);
                Canvas.SetTop(this, y);
                // Size the overlay to match the new container
#if WINDOWS_PHONE
                _overlay.Width = effectiveWidth;
                _overlay.Height = effectiveHeight;
#else
                _overlay.Width = _rootVisual.ActualWidth;
                _overlay.Height = _rootVisual.ActualHeight;
#endif
            }
        }

        /// <summary>
        /// Opens the Popup.
        /// </summary>
        /// <param name="position">Position to place the Popup.</param>
        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Code flow is reasonably clear.")]
        private void OpenPopup(Point position)
        {
            _popupAlignmentPoint = position;

            InitializeRootVisual();

            _overlay = new Canvas { Background = new SolidColorBrush(Colors.Transparent) };
            _overlay.MouseLeftButtonDown += new MouseButtonEventHandler(HandleOverlayMouseButtonDown);
#if !WINDOWS_PHONE
            _overlay.MouseRightButtonDown += new MouseButtonEventHandler(HandleOverlayMouseButtonDown);
#endif
            _overlay.Children.Add(this);

#if WINDOWS_PHONE
            if (IsZoomEnabled && (null != _rootVisual))
            {
                // Capture effective width/height
                bool portrait = PageOrientation.Portrait == (PageOrientation.Portrait & _rootVisual.Orientation);
                double width = portrait ? _rootVisual.ActualWidth : _rootVisual.ActualHeight;
                double height = portrait ? _rootVisual.ActualHeight : _rootVisual.ActualWidth;

                // Create a layer for the background brush
                UIElement backgroundLayer = new Rectangle
                {
                    Width = width,
                    Height = height,
                    Fill = new SolidColorBrush(Colors.White),
                };
                _overlay.Children.Insert(0, backgroundLayer);

                // Create a layer for the page content
                WriteableBitmap writeableBitmap = new WriteableBitmap((int)width, (int)height);
                writeableBitmap.Render(_rootVisual, null);
                writeableBitmap.Invalidate();
                Transform scaleTransform = new ScaleTransform
                {
                    CenterX = width / 2,
                    CenterY = height / 2,
                };
                UIElement contentLayer = new Image
                {
                    Source = writeableBitmap,
                    RenderTransform = scaleTransform,
                };
                _overlay.Children.Insert(1, contentLayer);

                // Create a layer for the owner element and its background
                FrameworkElement ownerElement = _owner as FrameworkElement;
                if (null != ownerElement)
                {
                    Point point = SafeTransformToVisual(ownerElement, _rootVisual).Transform(new Point());

                    // Create a layer for the element's background
                    UIElement elementBackground = new Rectangle
                    {
                        Width = ownerElement.ActualWidth,
                        Height = ownerElement.ActualHeight,
                        Fill = new SolidColorBrush(Colors.White),
                    };
                    Canvas.SetLeft(elementBackground, point.X);
                    Canvas.SetTop(elementBackground, point.Y);
                    _overlay.Children.Insert(2, elementBackground);

                    // Create a layer for the element
                    UIElement element = new Image { Source = new WriteableBitmap(ownerElement, null) };
                    Canvas.SetLeft(element, point.X);
                    Canvas.SetTop(element, point.Y);
                    _overlay.Children.Insert(3, element);
                }

                // Prepare for scale animation
                double from = 1;
                double to = 0.94;
                TimeSpan timespan = TimeSpan.FromSeconds(0.40);
                IEasingFunction easingFunction = new ExponentialEase { EasingMode = EasingMode.EaseInOut };
                _backgroundResizeStoryboard = new Storyboard();

                // Create an animation for the X scale
                DoubleAnimation animationX = new DoubleAnimation { From = from, To = to, Duration = timespan, EasingFunction = easingFunction };
                Storyboard.SetTarget(animationX, scaleTransform);
                Storyboard.SetTargetProperty(animationX, new PropertyPath(ScaleTransform.ScaleXProperty));
                _backgroundResizeStoryboard.Children.Add(animationX);

                // Create an animation for the Y scale
                DoubleAnimation animationY = new DoubleAnimation { From = from, To = to, Duration = timespan, EasingFunction = easingFunction };
                Storyboard.SetTarget(animationY, scaleTransform);
                Storyboard.SetTargetProperty(animationY, new PropertyPath(ScaleTransform.ScaleYProperty));
                _backgroundResizeStoryboard.Children.Add(animationY);

                // Play the animation
                _backgroundResizeStoryboard.Begin();
            }

            // Create transforms for handling rotation
            TransformGroup transforms = new TransformGroup();
            if (null != _rootVisual)
            {
                switch (_rootVisual.Orientation)
                {
                    case PageOrientation.LandscapeLeft:
                        transforms.Children.Add(new RotateTransform { Angle = 90 });
                        transforms.Children.Add(new TranslateTransform { X = _rootVisual.ActualWidth });
                        break;
                    case PageOrientation.LandscapeRight:
                        transforms.Children.Add(new RotateTransform { Angle = -90 });
                        transforms.Children.Add(new TranslateTransform { Y = _rootVisual.ActualHeight });
                        break;
                }
            }
            _overlay.RenderTransform = transforms;

            // Add Click handler for ApplicationBar Buttons
            if ((null != _page) && (null != _page.ApplicationBar) && (null != _page.ApplicationBar.Buttons))
            {
                foreach (object obj in _page.ApplicationBar.Buttons)
                {
                    ApplicationBarIconButton button = obj as ApplicationBarIconButton;
                    if (null != button)
                    {
                        button.Click += new EventHandler(HandleEventThatClosesContextMenu);
                        _applicationBarIconButtons.Add(button);
                    }
                }
            }
#endif

            _popup = new Popup { Child = _overlay };

            SizeChanged += new SizeChangedEventHandler(HandleContextMenuOrRootVisualSizeChanged);
            if (null != _rootVisual)
            {
                _rootVisual.SizeChanged += new SizeChangedEventHandler(HandleContextMenuOrRootVisualSizeChanged);
            }
            UpdateContextMenuPlacement();

            if (ReadLocalValue(DataContextProperty) == DependencyProperty.UnsetValue)
            {
                DependencyObject dataContextSource = Owner ?? _rootVisual;
                SetBinding(DataContextProperty, new Binding("DataContext") { Source = dataContextSource });
            }

            _popup.IsOpen = true;
            Focus();

            // Update IsOpen
            _settingIsOpen = true;
            IsOpen = true;
            _settingIsOpen = false;

            OnOpened(new RoutedEventArgs());
        }

        /// <summary>
        /// Closes the Popup.
        /// </summary>
        private void ClosePopup()
        {
#if WINDOWS_PHONE
            if (null != _backgroundResizeStoryboard)
            {
                // Swap all the From/To values to reverse the animation
                foreach (DoubleAnimation animation in _backgroundResizeStoryboard.Children)
                {
                    double temp = animation.From.Value;
                    animation.From = animation.To;
                    animation.To = temp;
                }

                // Capture member variables for delegate closure
                Popup popup = _popup;
                Panel overlay = _overlay;
                _backgroundResizeStoryboard.Completed += delegate
                {
                    // Clear/close popup and overlay
                    if (null != popup)
                    {
                        popup.IsOpen = false;
                        popup.Child = null;
                    }
                    if (null != overlay)
                    {
                        overlay.Children.Clear();
                    }
                };

                // Begin the reverse animation
                _backgroundResizeStoryboard.Begin();

                // Reset member variables
                _backgroundResizeStoryboard = null;
                _popup = null;
                _overlay = null;
            }
            else
            {
#endif
            if (null != _popup)
            {
                _popup.IsOpen = false;
                _popup.Child = null;
                _popup = null;
            }
            if (null != _overlay)
            {
                _overlay.Children.Clear();
                _overlay = null;
            }
#if WINDOWS_PHONE
            }
#endif
            SizeChanged -= new SizeChangedEventHandler(HandleContextMenuOrRootVisualSizeChanged);
            if (null != _rootVisual)
            {
                _rootVisual.SizeChanged -= new SizeChangedEventHandler(HandleContextMenuOrRootVisualSizeChanged);
            }

#if WINDOWS_PHONE
            // Remove Click handler for ApplicationBar Buttons
            foreach (ApplicationBarIconButton button in _applicationBarIconButtons)
            {
                button.Click -= new EventHandler(HandleEventThatClosesContextMenu);
            }
            _applicationBarIconButtons.Clear();
#endif

            // Update IsOpen
            _settingIsOpen = true;
            IsOpen = false;
            _settingIsOpen = false;

            OnClosed(new RoutedEventArgs());
        }
    }
}