/// <summary>
        /// Binds to specific events of the provided CoreWindow
        /// </summary>
        /// <param name="nativeWindow">A reference to <see cref="CoreWindow"/> or <see cref="UIElement"/> class.</param>
        /// <exception cref="ArgumentNullException">Is thrown when <paramref name="nativeWindow"/> is null.</exception>
        /// <exception cref="ArgumentException">Is thrown when <paramref name="nativeWindow"/> is not a <see cref="CoreWindow"/> and not an <see cref="UIElement"/></exception>
        protected override void BindWindow(object nativeWindow)
        {
            if (nativeWindow == null) throw new ArgumentNullException("nativeWindow");
            var window = nativeWindow as CoreWindow;
            if (window != null)
            {
                windowSize = new Size2F((float)window.Bounds.Width, (float)window.Bounds.Height);
                var position = window.PointerPosition;
                pointerPosition = new Vector2((float)position.X/windowSize.Width, (float)position.Y / windowSize.Height);

                window.PointerPressed += HandleWindowPointerEvent;
                window.PointerReleased += HandleWindowPointerEvent;
                window.PointerWheelChanged += HandleWindowPointerEvent;
                window.PointerMoved += HandleWindowPointerEvent;
                window.SizeChanged += window_SizeChanged;
                return;
            }

            uiElement = nativeWindow as FrameworkElement;
            if (uiElement != null)
            {
                windowSize = new Size2F((float)uiElement.ActualWidth, (float)uiElement.ActualHeight);
                uiElement.Loaded += HandleLoadedEvent;
                uiElement.SizeChanged += HandleSizeChangedEvent;
                uiElement.PointerPressed += HandleUIElementPointerEvent;
                uiElement.PointerReleased += HandleUIElementPointerEvent;
                uiElement.PointerWheelChanged += HandleUIElementPointerEvent;
                uiElement.PointerMoved += HandleUIElementPointerEvent;
                uiElement.PointerEntered += HandleUIElementPointerEvent;
                return;
            }

            throw new ArgumentException("Should be an instance of either CoreWindow or UIElement", "nativeWindow");
        }

        public static Control FindNearestStatefulControl(FrameworkElement element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            // Try to find an element which is the immediate child of a UserControl, ControlTemplate or other such "boundary" element
            FrameworkElement parent = element.Parent as FrameworkElement;

            // bubble up looking for a place to stop
            while (!VisualStateUtilities.HasVisualStateGroupsDefined(element) && VisualStateUtilities.ShouldContinueTreeWalk(parent))
            {
                element = parent;
                parent = parent.Parent as FrameworkElement;
            }

            if (VisualStateUtilities.HasVisualStateGroupsDefined(element))
            {
                // Once we've found such an element, use the VisualTreeHelper to get it's parent. For most elements the two are the 
                // same, but for children of a ControlElement this will give the control that contains the template.
                Control templatedParent = VisualTreeHelper.GetParent(element) as Control;

                if (templatedParent != null)
                {
                    return templatedParent;
                }
                else
                {
                    return element as Control;
                }
            }

            return null;
        }

        /// <summary>
        /// Returns true if the element is contained in a popup. 
        /// </summary>
        public static bool IsInPopup(FrameworkElement element)
        {
            if (element is Popup)
                return true;

            return GetParentPopup(element) != null; 
        }

        internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Line line)
        {
            var rect = line.GetBoundingRect(rootElement).ToSharpDX();
            var stroke = await line.Stroke.ToSharpDX(renderTarget, rect);

            if (stroke == null ||
                line.StrokeThickness <= 0)
            {
                return;
            }

            var layer = line.CreateAndPushLayerIfNecessary(renderTarget, rootElement);

            renderTarget.DrawLine(
                new Vector2(
                    rect.Left + (float)line.X1,
                    rect.Top + (float)line.Y1),
                new Vector2(
                    rect.Left + (float)line.X2,
                    rect.Top + (float)line.Y2),
                    stroke,
                    (float)line.StrokeThickness,
                    line.GetStrokeStyle(compositionEngine.D2DFactory));

            if (layer != null)
            {
                renderTarget.PopLayer();
                layer.Dispose();
            }
        }

        public static bool IsItemVisible(this FrameworkElement container, FrameworkElement element)
        {
            var elementBounds = element.TransformToVisual(container).TransformBounds(new Rect(0, 0, element.ActualWidth, element.ActualHeight));
            var containerBounds = new Rect(0, 0, container.ActualWidth, container.ActualHeight);

            return (elementBounds.Top < containerBounds.Bottom && elementBounds.Bottom > containerBounds.Top);
        }

        /// <summary>
        /// Goes to specified visual state, waiting for the transition to complete.
        /// </summary>
        /// <param name="control">
        /// Control to transition.
        /// </param>
        /// <param name="visualStatesHost">
        /// FrameworkElement that defines the visual states
        /// (usually the root of the control's template).
        /// </param>
        /// <param name="stateGroupName">
        /// Name of the state group
        /// (speeds up the search for the state transition storyboard).
        /// </param>
        /// <param name="stateName">
        /// State to transition to.
        /// </param>
        /// <returns>
        /// Awaitable task that completes when the transition storyboard completes.
        /// </returns>
        /// <remarks>
        /// If a state transition storyboard is not found - the task
        /// completes immediately.
        /// </remarks>
        public static async Task GoToVisualStateAsync(
            this Control control,
            FrameworkElement visualStatesHost, 
            string stateGroupName,
            string stateName)
        {
            var tcs = new TaskCompletionSource<Storyboard>();

            Storyboard storyboard =
                GetStoryboardForVisualState(visualStatesHost, stateGroupName, stateName);

            if (storyboard != null)
            {
                EventHandler<object> eh = null;

                eh = (s, e) =>
                {
                    storyboard.Completed -= eh;
                    tcs.SetResult(storyboard);
                };

                storyboard.Completed += eh;
            }

            VisualStateManager.GoToState(control, stateName, true);

            if (storyboard == null)
            {
                return;
            }

            await tcs.Task;
        }

 private void RevertRequestedTheme(FrameworkElement fe)
 {
     if (fe.RequestedTheme == ElementTheme.Default)
     {
         //The FrameworkElement doesn't have a RequestedTheme set, 
         //so we will need to ask to the Application what theme is using.
         if (Application.Current.RequestedTheme == ApplicationTheme.Dark)
         {
             fe.RequestedTheme = ElementTheme.Light;
         }
         else
         {
             fe.RequestedTheme = ElementTheme.Dark; 
         }
     }
     else if (fe.RequestedTheme == ElementTheme.Dark)
     {
         fe.RequestedTheme = ElementTheme.Light;
     }
     else
     {
         fe.RequestedTheme = ElementTheme.Dark;
     }
     CurrentThemeTxtBlock.Text = "Current theme is " + fe.RequestedTheme.ToString() + ".";
 }

        private bool GoToStateInternal(FrameworkElement stateGroupsRoot, string stateName, bool useTransitions)
        {
            VisualStateGroup group;
            VisualState state;

            return (TryGetState(stateGroupsRoot, stateName, out group, out state) && this.GoToStateCore(null, stateGroupsRoot, stateName, group, state, useTransitions));
        }

        /// <summary>Construct Get Image Samples sample control</summary>
        public GetSamples()
        {
            InitializeComponent();
			_graphicsOverlay = MyMapView.GraphicsOverlays.First();
			_mapTip = MyMapView.Overlays.Items.First() as FrameworkElement;
            MyMapView.LayerLoaded += MyMapView_LayerLoaded;
        }

        /// <summary>
        /// Decides whether the specified framework elements intersect within a canvas.
        /// </summary>
        /// <param name="first">The first framework element.</param>
        /// <param name="second">The second framework element.</param>
        /// <returns>True if the elements intersect. False otherwise.</returns>
        public static bool IntersectsWith(this FrameworkElement first, FrameworkElement second)
        {
            Rect p1 = first.Position();
            Rect p2 = second.Position();

            return (p1.Y + p1.Height < p2.Y) || (p1.Y > p2.Y + p2.Height) || (p1.X + p1.Width < p2.X) || (p1.X > p2.X + p2.Width);
        }

 private void ConsoleGainFocus(FrameworkElement grid)
 {
     ShowBackgroundImage(((Console)grid.DataContext).BackgroundLink);
     ConsoleFocus.Stop();
     Storyboard.SetTarget(ConsoleFocus, grid);
     ConsoleFocus.Begin();
 }

        /// <summary>Creates the default UI element generators.</summary>
        /// <param name="view">The view.</param>
        /// <returns>The generators.</returns>
        public static Dictionary<string, IControlGenerator> GetDefaultGenerators(FrameworkElement view)
        {
            var list = new Dictionary<string, IControlGenerator>();

            list.Add("p", new ParagraphGenerator());
            list.Add("div", new ParagraphGenerator());
            list.Add("blockquote", new ParagraphGenerator());
            list.Add("h1", new ParagraphGenerator { FontSize = 1.6 });
            list.Add("h2", new ParagraphGenerator { FontSize = 1.4 });
            list.Add("h3", new ParagraphGenerator { FontSize = 1.2 });

            list.Add("html", new HtmlGenerator());
            list.Add("strong", new StrongGenerator());
            list.Add("b", list["strong"]);
            list.Add("text", new TextGenerator());
            list.Add("em", new EmGenerator());
            list.Add("i", list["em"]);
            list.Add("a", new LinkGenerator());
            list.Add("img", new CacheImageGenerator());
            //list.Add("img", new ImageGenerator());
            list.Add("ul", new UlGenerator());
            list.Add("script", new EmptyGenerator());

            return list;
        }

        internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Line line)
        {
            var rect = line.GetBoundingRect(rootElement).ToSharpDX();
            //var fill = line.Fill.ToSharpDX(renderTarget, rect);
            var stroke = await line.Stroke.ToSharpDX(renderTarget, rect);

            if (stroke == null ||
                line.StrokeThickness <= 0)
            {
                return;
            }

            //var layer = new Layer(renderTarget);
            //var layerParameters = new LayerParameters();
            //layerParameters.ContentBounds = rect;
            //renderTarget.PushLayer(ref layerParameters, layer);

            renderTarget.DrawLine(
                new DrawingPointF(
                    rect.Left + (float)line.X1,
                    rect.Top + (float)line.Y1),
                new DrawingPointF(
                    rect.Left + (float)line.X2,
                    rect.Top + (float)line.Y2),
                    stroke,
                    (float)line.StrokeThickness,
                    line.GetStrokeStyle(compositionEngine.D2DFactory));

            //renderTarget.PopLayer();
        }

        private void UserControl_DataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
        {
            Graph.ClearSeries();

            var item = DataContext as ChartSong;
            if (item == null) return;

            var color = Colors.White;

            switch (item.ChangeDirection)
            {
                case ChartSong.Direction.Up:
                    color = Colors.Green;
                    break;
                case ChartSong.Direction.Down:
                    color = Colors.Red;
                    break;
            }

            ChangePercentBlock.Foreground = new SolidColorBrush(color);

            var data = item.Signals.Select((p, i) => new Point(i, p)).ToList();

            var serie = new Serie("Signals") {ShiftSize = 100};
            serie.SetData(data);

            Graph.AutoRedraw = true;
            Graph.AddSerie(serie);
        }

        //Do not use the below extension as it is slower than the one that follows
        //public static async Task Render(this WriteableBitmap wb, FrameworkElement fe)
        //{
        //    var ms = await RenderToPngStream(fe);

        //    using (var msrandom = new MemoryRandomAccessStream(ms))
        //    {
        //        await wb.SetSourceAsync(msrandom);
        //    }
        //}

        public static async Task<WriteableBitmap> Render(FrameworkElement fe)
        {
            using (var engine = new CompositionEngine())
            {
                return await engine.RenderToWriteableBitmap(fe);
            }
        }

 private void MenuControl_DataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
 {
     var propertyChanged = PropertyChanged;
     if (propertyChanged != null) {
         propertyChanged(this, new PropertyChangedEventArgs(nameof(ConcreteDataContext)));
     }
 }

 public static async Task<MemoryStream> RenderToPngStream(FrameworkElement fe)
 {
     using (var engine = new CompositionEngine())
     {
         return await engine.RenderToPngStream(fe);
     }
 }

        private async Task RenderUIElement(FrameworkElement elm, string fileName, int width, int height) {
            
            await System.Threading.Tasks.Task.Delay(TimeSpan.FromSeconds(1));

            using (InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream())
            {
                var renderTargetBitmap = new RenderTargetBitmap();
                await renderTargetBitmap.RenderAsync(elm);

                var pixels = await renderTargetBitmap.GetPixelsAsync();

                var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi;
                var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ms);
                encoder.SetPixelData(
                    BitmapPixelFormat.Bgra8,
                    BitmapAlphaMode.Ignore,
                    (uint)renderTargetBitmap.PixelWidth,
                    (uint)renderTargetBitmap.PixelHeight,
                    logicalDpi,
                    logicalDpi,
                    pixels.ToArray());

                await encoder.FlushAsync();

                await X.Services.Image.Service.Instance.GenerateResizedImageAsync(width, elm.ActualWidth, elm.ActualHeight, ms, fileName + ".png", Services.Image.Service.location.TileFolder, height);
            }

        }

        private void Animate(FrameworkElement element, double from, double to, TimeSpan duration, Action<FrameworkElement> completed)
        {
            AnimationTarget = element;
            TargetOpacity = to;
            AnimationCompleted = completed;

            if (_Storyboard == null)
            {
                Init();
            }
            else
            {
                _Storyboard.Stop();
            }

            /*time*/
            _KeyFrame_to.KeyTime = KeyTime.FromTimeSpan(duration);

            /*value*/
            _KeyFrame_from.Value = from;
            _KeyFrame_to.Value = to;

            Storyboard.SetTarget(_Animation, element);
            _Storyboard.Begin();
        }

        private void OnDataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
        {

            var m = this.DataContext as MessageRecord;
            if (m != null)
            {
                this.MessageRecord = m;
                VisualStateManager.GoToState(this, m.IsOutgoing ? "Outgoing" : "Incoming", true);


                if (m.IsFailed)
                {
                    VisualStateManager.GoToState(this, "Failed", true);
                }
                else
                {
                    if (!m.IsOutgoing) VisualStateManager.GoToState(this, "None", true);
                    else if (m.IsPending) VisualStateManager.GoToState(this, "Pending", true);
                    else if (m.IsDelivered) VisualStateManager.GoToState(this, "Delivered", true);
                    else VisualStateManager.GoToState(this, "Sent", true);
                }

                if (m.IsKeyExchange)
                {
                    VisualStateManager.GoToState(this, "KeyExchange", true);
                }
            }
        }