using DevComponents.DotNetBar;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace DevComponents.DotNetBar.Controls
{
    /// <summary>
    /// Component to display flyout popup.
    /// </summary>
    [ToolboxBitmap(typeof(Flyout), "Controls.Flyout.ico")]
    [ToolboxItem(true), Designer("DevComponents.DotNetBar.Design.FlyoutDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf")]
    [DefaultEvent("PrepareContent")]
    public partial class Flyout : Component, IMessageHandlerClient
    {
        #region Constructor
        public Flyout()
        {
            InitializeComponent();
        }

        public Flyout(IContainer container)
        {
            container.Add(this);

            InitializeComponent();
        }
        #endregion

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            Close();
            if (_MessageHandlerInstalled)
            {
                MessageHandler.UnregisterMessageClient(this);
                _MessageHandlerInstalled = false;
            }
            if (disposing && (components != null))
            {
                components.Dispose();
            }

            base.Dispose(disposing);
        }

        #region Component Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
        }

        #endregion

        #region Implementation
        private bool _DropShadow;
        private bool _TopMost;
        private Control _Content = null;
        /// <summary>
        /// Indicates a control, usually panel with other controls inside of it, that is displayed on the flyout popup.
        /// </summary>
        [DefaultValue(null), Category("Appearance"), Description("Indicates a control, usually panel with other controls inside of it, that is displayed on the flyout popup.")]
        public Control Content
        {
            get { return _Content; }
            set
            {
                if (value != _Content)
                {
                    Control oldValue = _Content;
                    _Content = value;
                    OnContentChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Content property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnContentChanged(Control oldValue, Control newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("Content"));

        }

        private ePointerSide _PointerSide = ePointerSide.Bottom;
        /// <summary>
        /// Indicates the side of the flyout triangle pointer is displayed on.
        /// </summary>
        [DefaultValue(ePointerSide.Bottom), Category("Appearance"), Description("Indicates the side of the flyout triangle pointer is displayed on.")]
        public ePointerSide PointerSide
        {
            get { return _PointerSide; }
            set
            {
                if (value != _PointerSide)
                {
                    ePointerSide oldValue = _PointerSide;
                    _PointerSide = value;
                    OnPointerSideChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when PointerSide property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnPointerSideChanged(ePointerSide oldValue, ePointerSide newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("PointerSide"));
        }

        private Control _TargetControl = null;
        /// <summary>
        /// Indicates the target control for the flyout display and positioning.
        /// </summary>
        [DefaultValue(null), Category("Behavior"), Description("Indicates the target control for the flyout display and positioning.")]
        public Control TargetControl
        {
            get { return _TargetControl; }
            set
            {
                if (value != _TargetControl)
                {
                    Control oldValue = _TargetControl;
                    _TargetControl = value;
                    OnTargetControlChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when TargetControl property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTargetControlChanged(Control oldValue, Control newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("TargetControl"));
            if (!this.DesignMode)
            {
                DetachFromControl(oldValue, _DisplayMode, _DeepIntegration);
                AttachToControl(newValue, _DisplayMode, _DeepIntegration);
            }
        }

        private void AttachToControl(Control c, eFlyoutDisplayMode displayMode, bool deepIntegration)
        {
            if (c == null) return;
            if (displayMode == eFlyoutDisplayMode.MouseClick)
            {
                if (deepIntegration && c is SuperTabControl)
                {
                    SuperTabControl tab = (SuperTabControl)c;
                    tab.TabStrip.ItemClick += TabStripMouseEvent;
                }
                else if (deepIntegration && c is AdvTree.AdvTree)
                {
                    AdvTree.AdvTree tree = (AdvTree.AdvTree)c;
                    tree.NodeClick += TreeMouseEvent;
                }
                else if (deepIntegration && c is TokenEditor)
                {
                    TokenEditor token = (TokenEditor)c;
                    token.TokenMouseClick += TokenMouseEvent;
                }
                else if (deepIntegration && c is TabStrip)
                {
                    TabStrip strip = (TabStrip)c;
                    strip.TabMouseClick += TabItemMouseEvent;
                }
                else if (deepIntegration && c is TabControl)
                {
                    TabControl strip = (TabControl)c;
                    strip.TabStrip.TabMouseClick += TabItemMouseEvent;
                }
                else if (deepIntegration && c is Bar)
                {
                    Bar bar = (Bar)c;
                    bar.ItemClick += BaseItemMouseEvent;
                }
                else
                    c.MouseClick += TargetMouseClick;
            }
            else if (displayMode == eFlyoutDisplayMode.MouseHover)
            {
                if (deepIntegration && c is SuperTabControl)
                {
                    SuperTabControl tab = (SuperTabControl)c;
                    tab.TabStrip.MouseHover += TabStripMouseEvent;
                    tab.TabStrip.MouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is AdvTree.AdvTree)
                {
                    AdvTree.AdvTree tree = (AdvTree.AdvTree)c;
                    tree.NodeMouseHover += TreeMouseEvent;
                    tree.NodeMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is TokenEditor)
                {
                    TokenEditor token = (TokenEditor)c;
                    token.TokenMouseHover += TokenMouseEvent;
                    token.TokenMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is TabStrip)
                {
                    TabStrip tab = (TabStrip)c;
                    tab.TabMouseHover += TabItemMouseEvent;
                    tab.TabMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is TabControl)
                {
                    TabControl tab = (TabControl)c;
                    tab.TabStrip.TabMouseHover += TabItemMouseEvent;
                    tab.TabStrip.TabMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is Bar)
                {
                    Bar bar = (Bar)c;
                    bar.MouseHover += BaseItemMouseEvent;
                    bar.MouseLeave += TargetMouseLeave;
                }
                else
                    c.MouseHover += TargetMouseHover;
            }
            else if (displayMode == eFlyoutDisplayMode.MouseOver)
            {
                if (deepIntegration && c is SuperTabControl)
                {
                    SuperTabControl tab = (SuperTabControl)c;
                    tab.TabStrip.MouseEnter += TabStripMouseEvent;
                    tab.TabStrip.MouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is AdvTree.AdvTree)
                {
                    AdvTree.AdvTree tree = (AdvTree.AdvTree)c;
                    tree.NodeMouseEnter += TreeMouseEvent;
                    tree.NodeMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is TokenEditor)
                {
                    TokenEditor token = (TokenEditor)c;
                    token.TokenMouseEnter += TokenMouseEvent;
                    token.TokenMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is TabStrip)
                {
                    TabStrip tab = (TabStrip)c;
                    tab.TabMouseEnter += TabItemMouseEvent;
                    tab.TabMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is TabControl)
                {
                    TabControl tab = (TabControl)c;
                    tab.TabStrip.TabMouseEnter += TabItemMouseEvent;
                    tab.TabStrip.TabMouseLeave += TargetMouseLeave;
                }
                else if (deepIntegration && c is Bar)
                {
                    Bar bar = (Bar)c;
                    bar.MouseMove += BaseItemMouseEvent;
                    bar.MouseLeave += TargetMouseLeave;
                }
                else
                    c.MouseEnter += TargetMouseEnter;
            }
            c.Leave += TargetLeaveFocus;
            c.VisibleChanged += TargetVisibleChanged;
        }

        private void DetachFromControl(Control c, eFlyoutDisplayMode displayMode, bool deepIntegration)
        {
            if (c == null) return;
            if (displayMode == eFlyoutDisplayMode.MouseClick)
            {
                if (deepIntegration && c is SuperTabControl)
                {
                    SuperTabControl tab = (SuperTabControl)c;
                    tab.TabStrip.ItemClick -= TabStripMouseEvent;
                }
                else if (deepIntegration && c is AdvTree.AdvTree)
                {
                    AdvTree.AdvTree tree = (AdvTree.AdvTree)c;
                    tree.NodeClick -= TreeMouseEvent;
                }
                else if (deepIntegration && c is TokenEditor)
                {
                    TokenEditor token = (TokenEditor)c;
                    token.TokenMouseClick -= TokenMouseEvent;
                }
                else if (deepIntegration && c is TabStrip)
                {
                    TabStrip strip = (TabStrip)c;
                    strip.TabMouseClick -= TabItemMouseEvent;
                }
                else if (deepIntegration && c is TabControl)
                {
                    TabControl strip = (TabControl)c;
                    strip.TabStrip.TabMouseClick -= TabItemMouseEvent;
                }
                else if (deepIntegration && c is Bar)
                {
                    Bar bar = (Bar)c;
                    bar.ItemClick -= BaseItemMouseEvent;
                }
                else
                    c.MouseClick -= TargetMouseClick;
            }
            else if (displayMode == eFlyoutDisplayMode.MouseHover)
            {
                if (deepIntegration && c is SuperTabControl)
                {
                    SuperTabControl tab = (SuperTabControl)c;
                    tab.TabStrip.MouseHover -= TabStripMouseEvent;
                    tab.TabStrip.MouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is AdvTree.AdvTree)
                {
                    AdvTree.AdvTree tree = (AdvTree.AdvTree)c;
                    tree.NodeMouseHover -= TreeMouseEvent;
                    tree.NodeMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is TokenEditor)
                {
                    TokenEditor token = (TokenEditor)c;
                    token.TokenMouseHover -= TokenMouseEvent;
                    token.TokenMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is TabStrip)
                {
                    TabStrip tab = (TabStrip)c;
                    tab.TabMouseHover -= TabItemMouseEvent;
                    tab.TabMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is TabControl)
                {
                    TabControl tab = (TabControl)c;
                    tab.TabStrip.TabMouseHover -= TabItemMouseEvent;
                    tab.TabStrip.TabMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is Bar)
                {
                    Bar bar = (Bar)c;
                    bar.MouseHover -= BaseItemMouseEvent;
                    bar.MouseLeave -= TargetMouseLeave;
                }
                else
                    c.MouseHover -= TargetMouseHover;
            }
            else if (displayMode == eFlyoutDisplayMode.MouseOver)
            {
                if (deepIntegration && c is SuperTabControl)
                {
                    SuperTabControl tab = (SuperTabControl)c;
                    tab.TabStrip.MouseEnter -= TabStripMouseEvent;
                    tab.TabStrip.MouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is AdvTree.AdvTree)
                {
                    AdvTree.AdvTree tree = (AdvTree.AdvTree)c;
                    tree.NodeMouseEnter -= TreeMouseEvent;
                    tree.NodeMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is TokenEditor)
                {
                    TokenEditor token = (TokenEditor)c;
                    token.TokenMouseEnter -= TokenMouseEvent;
                    token.TokenMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is TabStrip)
                {
                    TabStrip tab = (TabStrip)c;
                    tab.TabMouseEnter -= TabItemMouseEvent;
                    tab.TabMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is TabControl)
                {
                    TabControl tab = (TabControl)c;
                    tab.TabStrip.TabMouseEnter -= TabItemMouseEvent;
                    tab.TabStrip.TabMouseLeave -= TargetMouseLeave;
                }
                else if (deepIntegration && c is Bar)
                {
                    Bar bar = (Bar)c;
                    bar.MouseEnter -= BaseItemMouseEvent;
                    bar.MouseLeave -= TargetMouseLeave;
                }
                else
                    c.MouseEnter -= TargetMouseEnter;
            }
            c.Leave -= TargetLeaveFocus;
            c.VisibleChanged -= TargetVisibleChanged;
        }
        private bool _CloseDelayed = false;
        private void TargetMouseLeave(object sender, EventArgs e)
        {
            if (_IsFlyoutFormShown)
            {
                _CloseDelayed = true;
                BarUtilities.InvokeDelayed(new MethodInvoker(delegate { CloseFlyoutDelayed(); }), 1000);
                //Close();
            }
        }
        private void CloseFlyoutDelayed()
        {
            if (!_CloseDelayed) return;
            _CloseDelayed = false;
            if (_IsFlyoutFormShown && _Flyout!=null && !_Flyout.Bounds.Contains(Control.MousePosition) && 
                _TargetControl!=null && !(new Rectangle(_TargetControl.PointToScreen(_TargetControl.Location), _TargetControl.Size).Contains(Control.MousePosition)))
            {
                Close();
            }
        }
        private void TokenMouseEvent(object sender, EventArgs e)
        {
            if (_IsFlyoutFormShown)
                Close();
            Show(sender);
        }
        private void TreeMouseEvent(object sender, AdvTree.TreeNodeMouseEventArgs e)
        {
            if (_IsFlyoutFormShown)
                Close();
            Show(e.Node);
        }
        private void TabItemMouseEvent(object sender, EventArgs e)
        {
            if (sender is TabItem)
            {
                if (_IsFlyoutFormShown)
                    Close();
                if (!_IsFlyoutFormShown)
                {
                    Show(sender);
                }
            }
            else
                Close();
        }
        private void BaseItemMouseEvent(object sender, EventArgs e)
        {
            if (sender is BaseItem)
            {
                if (_IsFlyoutFormShown)
                    Close();
                if (!_IsFlyoutFormShown)
                {
                    Show(sender);
                }
            }
            else if (sender is Bar)
            {
                Bar bar = (Bar)sender;
                Point p = bar.PointToClient(Control.MousePosition);
                BaseItem item = bar.ItemsContainer.ItemAtLocation(p.X, p.Y);
                if (item != null)
                {
                    if (_TargetItem != null && _TargetItem.IsAlive && _TargetItem.Target == item)
                        return;
                    
                    if (_IsFlyoutFormShown)
                        Close();
                    
                    if (!_IsFlyoutFormShown)
                    {
                        Show(item);
                    }
                }
                else
                    Close();
            }
            else
                Close();
        }
        private void TabStripMouseEvent(object sender, EventArgs e)
        {
            if (sender is SuperTabItem)
            {
                if (_IsFlyoutFormShown)
                    Close();
                if (!_IsFlyoutFormShown)
                {
                    Show(sender);
                }
            }
            else
                Close();
        }

        private bool _DeepIntegration = true;
        /// <summary>
        /// Indicates whether Flyout integrates on item level with DotNetBar controls it recognizes like SuperTabControl, AdvTree etc.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether Flyout integrates on item level with DotNetBar controls it recognizes like SuperTabControl, AdvTree etc.")]
        public bool DeepIntegration
        {
            get { return _DeepIntegration; }
            set
            {
                if (value != _DeepIntegration)
                {
                    bool oldValue = _DeepIntegration;
                    _DeepIntegration = value;
                    OnDeepControlIntegrationChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when DeepControlIntegration property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnDeepControlIntegrationChanged(bool oldValue, bool newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("DeepControlIntegration"));
            DetachFromControl(_TargetControl, _DisplayMode, oldValue);
            AttachToControl(_TargetControl, _DisplayMode, newValue);
        }

        private void TargetVisibleChanged(object sender, EventArgs e)
        {
            if ((_CloseMode & eFlyoutCloseMode.TargetControlHidden) == eFlyoutCloseMode.TargetControlHidden && _TargetControl != null && !_TargetControl.Visible)
                Close();
        }
        void TargetLeaveFocus(object sender, EventArgs e)
        {
            if ((_CloseMode & eFlyoutCloseMode.TargetControlLostFocus) == eFlyoutCloseMode.TargetControlLostFocus)
                Close();
        }

        void TargetMouseEnter(object sender, EventArgs e)
        {
            if (!_IsFlyoutFormShown)
                Show();
        }

        void TargetMouseHover(object sender, EventArgs e)
        {
            if (!_IsFlyoutFormShown)
                Show();
        }
        private void TargetMouseClick(object sender, MouseEventArgs e)
        {
            if (!_IsFlyoutFormShown)
                Show();
        }
        private eFlyoutDisplayMode _DisplayMode = eFlyoutDisplayMode.MouseOver;
        /// <summary>
        /// Specifies when the flyout is displayed.
        /// </summary>
        [DefaultValue(eFlyoutDisplayMode.MouseOver), Category("Behavior"), Description("Specifies when the flyout is displayed.")]
        public eFlyoutDisplayMode DisplayMode
        {
            get { return _DisplayMode; }
            set
            {
                if (value != _DisplayMode)
                {
                    eFlyoutDisplayMode oldValue = _DisplayMode;
                    _DisplayMode = value;
                    OnDisplayModeChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when DisplayMode property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnDisplayModeChanged(eFlyoutDisplayMode oldValue, eFlyoutDisplayMode newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("DisplayMode"));
            DetachFromControl(_TargetControl, oldValue, _DeepIntegration);
            AttachToControl(_TargetControl, newValue, _DeepIntegration);
        }

        private eFlyoutCloseMode _CloseMode = eFlyoutCloseMode.ClickOutside | eFlyoutCloseMode.ParentFormDeactivate;
        /// <summary>
        /// Indicates when Flyout is automatically closed.
        /// </summary>
        [DefaultValue(eFlyoutCloseMode.ClickOutside | eFlyoutCloseMode.ParentFormDeactivate), Category("Behavior"), Description("Indicates when Flyout is automatically closed.")]
        public eFlyoutCloseMode CloseMode
        {
            get { return _CloseMode; }
            set
            {
                if (value != _CloseMode)
                {
                    eFlyoutCloseMode oldValue = _CloseMode;
                    _CloseMode = value;
                    OnCloseModeChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when CloseMode property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnCloseModeChanged(eFlyoutCloseMode oldValue, eFlyoutCloseMode newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("CloseMode"));

        }

        private Rectangle GetTargetBounds(object targetItem)
        {
            if (targetItem is BaseItem)
            {
                BaseItem item = (BaseItem)targetItem;
                return new Rectangle(_TargetControl.PointToScreen(item.Bounds.Location), item.Bounds.Size);
            }
            else if (targetItem is DevComponents.AdvTree.Node)
            {
                DevComponents.AdvTree.Node node = (DevComponents.AdvTree.Node)targetItem;
                return new Rectangle(_TargetControl.PointToScreen(node.Bounds.Location), node.Bounds.Size);
            }
            else if(targetItem is EditToken)
            {
                EditToken token = (EditToken)targetItem;
                return new Rectangle(_TargetControl.PointToScreen(token.Bounds.Location), token.Bounds.Size);
            }
            else if (targetItem is TabItem)
            {
                TabItem tab = (TabItem)targetItem;
                return new Rectangle(_TargetControl.PointToScreen(tab.DisplayRectangle.Location), tab.DisplayRectangle.Size);
            }

            return new Rectangle(_TargetControl.PointToScreen(Point.Empty), _TargetControl.Size);
        }

        /// <summary>
        /// Occurs before the flyout is shown for specific target and allows you to prepare Content for it. Sender of event will be the targeted control or item.
        /// </summary>
        [Description("Occurs before the flyout is shown for specific target and allows you to prepare Content for it. Sender of event will be the targeted control or item.")]
        public event EventHandler PrepareContent;
        /// <summary>
        /// Raises PrepareContent event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnPrepareContent(object sender, EventArgs e)
        {
            EventHandler handler = PrepareContent;
            if (handler != null)
                handler(sender, e);
        }

        public virtual void Show(object targetItem)
        {
            OnPrepareContent(targetItem, EventArgs.Empty);

            Rectangle r = new Rectangle();
            ePointerSide pointerSide = _PointerSide;
            int pointerOffset = 10;

            if (_TargetControl != null)
            {
                Rectangle targetBounds = GetTargetBounds(targetItem ?? _TargetControl);
                ScreenInformation si = BarFunctions.ScreenFromControl(_TargetControl);
                if (pointerSide == ePointerSide.Top)
                {
                    // Displaying callout below the control
                    r.Size = GetFlyoutFormSize();
                    if (targetBounds.Bottom + r.Height > si.WorkingArea.Bottom)
                    {
                        // Move flyout above the control
                        pointerSide = ePointerSide.Bottom;
                        r.Location = new Point(targetBounds.X, targetBounds.Y - r.Height);
                    }
                    else
                        r.Location = new Point(targetBounds.X, targetBounds.Bottom);
                    if (targetBounds.Width > r.Width)
                        r.X += (targetBounds.Width - r.Width) / 2;
                    else if (targetBounds.Width < r.Width)
                        r.X -= (r.Width - targetBounds.Width) / 2;
                    if (r.X < si.WorkingArea.X)
                        r.X = si.WorkingArea.X;
                    else if (r.Right > si.WorkingArea.Right)
                        r.X = si.WorkingArea.Right - r.Width;
                    Rectangle intersect = Rectangle.Intersect(r, new Rectangle(targetBounds.X, r.Y, targetBounds.Width, r.Height));
                    if (intersect.IsEmpty)
                        pointerOffset = (Math.Min(targetBounds.Width, r.Width) - FlyoutForm.PointerSize.Width) / 2;
                    else
                        pointerOffset = Math.Abs(intersect.X - r.X) + (intersect.Width - FlyoutForm.PointerSize.Width) / 2;
                }
                else if (pointerSide == ePointerSide.Bottom)
                {
                    // Displaying callout above the control
                    r.Size = GetFlyoutFormSize();
                    if (targetBounds.Y - r.Height < si.WorkingArea.Y)
                    {
                        // Move flyout below the control
                        pointerSide = ePointerSide.Top;
                        r.Location = new Point(targetBounds.X, targetBounds.Bottom);
                    }
                    else
                        r.Location = new Point(targetBounds.X, targetBounds.Y - r.Height);
                    if (targetBounds.Width > r.Width)
                        r.X += (targetBounds.Width - r.Width) / 2;
                    else if (targetBounds.Width < r.Width)
                        r.X -= (r.Width - targetBounds.Width) / 2;
                    if (r.X < si.WorkingArea.X)
                        r.X = si.WorkingArea.X;
                    else if (r.Right > si.WorkingArea.Right)
                        r.X = si.WorkingArea.Right - r.Width;
                    Rectangle intersect = Rectangle.Intersect(r, new Rectangle(targetBounds.X, r.Y, targetBounds.Width, r.Height));
                    if (intersect.IsEmpty)
                        pointerOffset = (Math.Min(targetBounds.Width, r.Width) - FlyoutForm.PointerSize.Width) / 2;
                    else
                        pointerOffset = Math.Abs(intersect.X - r.X) + (intersect.Width - FlyoutForm.PointerSize.Width) / 2;
                }
                else if (pointerSide == ePointerSide.Left)
                {
                    // Displaying callout to the right of the target control
                    r.Size = GetFlyoutFormSize();
                    if (targetBounds.Right + r.Width > si.WorkingArea.Right)
                    {
                        // Move flyout to the left of the control
                        pointerSide = ePointerSide.Right;
                        r.Location = new Point(targetBounds.X - r.Width, targetBounds.Y);
                    }
                    else
                        r.Location = new Point(targetBounds.Right, targetBounds.Y);

                    if (targetBounds.Height > r.Height)
                        r.Y += (targetBounds.Height - r.Height) / 2;
                    pointerOffset = (Math.Min(targetBounds.Height, r.Height) - FlyoutForm.PointerSize.Width) / 2;
                }
                else if (pointerSide == ePointerSide.Right)
                {
                    // Displaying callout to the Left of the target control
                    r.Size = GetFlyoutFormSize();
                    if (targetBounds.X - r.Width < si.WorkingArea.X)
                    {
                        // Move flyout to the right of the control
                        pointerSide = ePointerSide.Left;
                        r.Location = new Point(targetBounds.Right, targetBounds.Y);
                    }
                    else
                        r.Location = new Point(targetBounds.X - r.Width, targetBounds.Y);

                    if (targetBounds.Height > r.Height)
                        r.Y += (targetBounds.Height - r.Height) / 2;
                    pointerOffset = (Math.Min(targetBounds.Height, r.Height) - FlyoutForm.PointerSize.Width) / 2;
                }
            }
            Show(r, pointerSide, pointerOffset, targetItem);
        }

        /// <summary>
        /// Shows flyout with the Content. 
        /// </summary>
        public virtual void Show()
        {
            Show(_TargetControl);
        }

        /// <summary>
        /// Returns the flyout size based on Content size.
        /// </summary>
        /// <returns>Proposed flyout size.</returns>
        public virtual Size GetFlyoutFormSize()
        {
            if (_Content != null)
            {
                Size size = _Content.Size;
                if (_PointerSide == ePointerSide.Bottom || _PointerSide == ePointerSide.Top)
                {
                    size.Height += FlyoutForm.PointerSize.Height + 4;
                    size.Width += 2;
                }
                else
                {
                    size.Width += FlyoutForm.PointerSize.Height + 4;
                    size.Height += 2;
                }
                return size;
            }
            return new Size(100, 100);
        }
        /// <summary>
        /// Shows flyout at specified location and with specified size. Size can be empty (0,0) and flyout will be automatically sized based on the content.
        /// </summary>
        /// <param name="screenFlyoutBounds"></param>
        public virtual void Show(Rectangle screenFlyoutBounds)
        {
            Show(screenFlyoutBounds, _PointerSide, 10, _TargetControl);
        }
        [Description("Occurs before the flyout form is shown and allows you to cancel the showing.")]
        public event FlyoutShowingEventHandler FlyoutShowing;
        /// <summary>
        /// Raises FlyoutShowing event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnFlyoutShowing(FlyoutShowingEventArgs e)
        {
            FlyoutShowingEventHandler handler = FlyoutShowing;
            if (handler != null)
                handler(this, e);
        }
        /// <summary>
        /// Occurs after flyout has been shown.
        /// </summary>
        [Description("Occurs after flyout has been shown.")]
        public event EventHandler FlyoutShown;
        /// <summary>
        /// Raises FlyoutShown event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnFlyoutShown(EventArgs e)
        {
            EventHandler handler = FlyoutShown;
            if (handler != null)
                handler(this, e);
        }

        /// <summary>
        /// Provides opportunity to cancel showing of the flyout before any objects are created and allocated. This is preferred event to cancel flyout showing.
        /// </summary>
        [Description("Provides opportunity to cancel showing of the flyout before any objects are created and allocated. This is preferred event to cancel flyout showing.")]
        public event CancelEventHandler QueryShowFlyout;
        /// <summary>
        /// Raises QueryShowFlyout event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnQueryShowFlyout(object sender, CancelEventArgs e)
        {
            CancelEventHandler handler = QueryShowFlyout;
            if (handler != null)
                handler(sender, e);
        }

        private bool _IsFlyoutFormShown = false;
        private Control _OldContentParent = null;
        private WeakReference _TargetItem = null;
        private FlyoutForm _Flyout = null;

        /// <summary>
        /// Gets reference to active FlyoutForm or return null/nothing if flyout is not currently shown.
        /// </summary>
        [Browsable(false)]
        public FlyoutForm FlyoutForm
        {
            get { return _Flyout; }
        }

        /// <summary>
        /// Shows flyout at specified location and with specified size. Size can be empty (0,0) and flyout will be automatically sized based on the content.
        /// </summary>
        /// <param name="screenFlyoutBounds">Screen bounds to display flyout at.</param>
        /// <param name="pointerSide">Side of the flyout which will have pointer triangle</param>
        /// <param name="pointerOffset">Pointer position either x or y depending on which side pointer is displayed on.</param>
        /// <param name="targetItem">Target item for the flyout.</param>
        public virtual void Show(Rectangle screenFlyoutBounds, ePointerSide pointerSide, int pointerOffset, object targetItem)
        {
            _CloseDelayed = false;
            if (_IsFlyoutFormShown)
            {
                if (_Flyout != null) _Flyout.Activate();
                return;
            }

            CancelEventArgs cancelShow = new CancelEventArgs();
            OnQueryShowFlyout(targetItem??_TargetControl,cancelShow);
            if (cancelShow.Cancel) return;

            FlyoutForm form = new FlyoutForm();
            if (!_BorderColor.IsEmpty)
                form.BorderColor = _BorderColor;
            if (!_BackColor.IsEmpty)
                form.BackColor = _BackColor;
            form.PointerSide = pointerSide;
            form.ActivateOnShow = _ActivateOnShow;
            form.TopMost = _TopMost;
            form.DropShadow = _DropShadow;
            form.PointerOffset = pointerOffset;
            if (_Content != null)
            {
                if (screenFlyoutBounds.Size.IsEmpty)
                {
                    screenFlyoutBounds.Size = GetFlyoutFormSize();
                }

                if (_Content.Parent != null)
                {
                    _OldContentParent = _Content.Parent;
                    _OldContentParent.Controls.Remove(_Content);
                }

                form.Controls.Add(_Content);
                _Content.Location = new Point(
                    (pointerSide == ePointerSide.Left) ? FlyoutForm.PointerSize.Height + 1 : 1,
                    (pointerSide == ePointerSide.Top) ? FlyoutForm.PointerSize.Height + 1 : 1);
                _Content.Visible = true;
            }

            form.Size = Size.Empty;
            form.Location = screenFlyoutBounds.Location;
            form.FormClosed += FlyoutFormClosed;
            form.FormClosing += FlyoutFormClosing;
            FlyoutShowingEventArgs eargs = new FlyoutShowingEventArgs(form, targetItem);
            OnFlyoutShowing(eargs);
            if (eargs.Cancel)
            {
                FlyoutCloseCleanup(form);
                form.Close();
                form.Dispose();
                return;
            }
            _IsFlyoutFormShown = true;
            form.Visible = true;
            form.Size = screenFlyoutBounds.Size;
            _Flyout = form;
            _TargetItem = new WeakReference(targetItem);
            OnFlyoutShown(EventArgs.Empty);

            if (!_MessageHandlerInstalled && (_CloseMode & eFlyoutCloseMode.ClickOutside) == eFlyoutCloseMode.ClickOutside)
            {
                MessageHandler.RegisterMessageClient(this);
                _MessageHandlerInstalled = true;
            }

            if (_Parent != null && (_CloseMode & eFlyoutCloseMode.ParentFormDeactivate) == eFlyoutCloseMode.ParentFormDeactivate)
            {
                Form parentForm = null;
                if (_Parent is Form)
                    parentForm = (Form)_Parent;
                else
                    parentForm = _Parent.FindForm();
                if (parentForm != null)
                {
                    parentForm.Deactivate += ParentFormDeactivate;
                    _ParentForm = parentForm;
                }
            }
        }

        /// <summary>
        /// Occurs before flyout is closed and allows you to cancel the closing.
        /// </summary>
        [Description("Occurs before flyout is closed and allows you to cancel the closing.")]
        public event FormClosingEventHandler FlyoutClosing;
        /// <summary>
        /// Raises FlyoutClosing event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnFlyoutClosing(FormClosingEventArgs e)
        {
            FormClosingEventHandler handler = FlyoutClosing;
            if (handler != null)
                handler(this, e);
        }
        private void FlyoutFormClosing(object sender, FormClosingEventArgs e)
        {
            OnFlyoutClosing(e);
        }

        /// <summary>
        /// Occurs after flyout is closed.
        /// </summary>
        [Description("Occurs after flyout is closed.")]
        public event FormClosedEventHandler FlyoutClosed;
        /// <summary>
        /// Raises FlyoutClosed event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnFlyoutClosed(FormClosedEventArgs e)
        {
            FormClosedEventHandler handler = FlyoutClosed;
            if (handler != null)
                handler(this, e);
        }

        private Form _ParentForm = null;
        void ParentFormDeactivate(object sender, EventArgs e)
        {
            if (_Flyout != null && _Flyout.Bounds.Contains(Control.MousePosition))
                return;
            Close();
        }

        /// <summary>
        /// Closes the flyout form if it was open.
        /// </summary>
        public virtual void Close()
        {
            FlyoutForm flyout = _Flyout;
            if (flyout != null)
            {
                flyout.Close();
                flyout.Dispose();
            }
        }

        private void FlyoutCloseCleanup(FlyoutForm form)
        {
            _TargetItem = null;
            _IsFlyoutFormShown = false;
            form.FormClosed -= FlyoutFormClosed;
            form.Controls.Remove(_Content);
            if (_OldContentParent != null)
            {
                _Content.Visible = false;
                _OldContentParent.Controls.Add(_Content);
                _OldContentParent = null;
            }
            _Flyout = null;
            if (_ParentForm != null)
            {
                _ParentForm.Deactivate -= ParentFormDeactivate;
                _ParentForm = null;
            }
        }
        private void FlyoutFormClosed(object sender, FormClosedEventArgs e)
        {
            FlyoutForm form = (FlyoutForm)sender;
            OnFlyoutClosed(e);
            FlyoutCloseCleanup(form);
        }

        private bool _ActivateOnShow = false;
        /// <summary>
        /// Indicates whether flyout is active/focused when its shown, default value is false.
        /// </summary>
        [DefaultValue(false), Category("Behavior"), Description("Indicates whether flyout is active/focused when its shown, default value is false.")]
        public bool ActivateOnShow
        {
            get { return _ActivateOnShow; }
            set
            {
                if (value != _ActivateOnShow)
                {
                    bool oldValue = _ActivateOnShow;
                    _ActivateOnShow = value;
                    OnActivateOnShowChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when ActivateOnShow property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnActivateOnShowChanged(bool oldValue, bool newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("ActivateOnShow"));

        }

        /// <summary>
        /// Indicates whether flyout is made top-most window when shown
        /// </summary>
        [DefaultValue(false), Category("Behavior"), Description("Indicates whether flyout is made top-most window when shown.")]
        public bool TopMost
        {
            get { return _TopMost; }
            set
            {
                if (value != _TopMost)
                {
                    bool oldValue = _TopMost;
                    _TopMost = value;
                    OnTopMostChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when TopMost property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTopMostChanged(bool oldValue, bool newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("TopMost"));

        }

        private Color _BackColor = Color.Empty;
        /// <summary>
        /// Gets or sets the background flyout color. Default value is Color.Empty which indicates that current color scheme will be used.
        /// </summary>
        [Category("Columns"), Description("Indicates background flyout color. Default value is Color.Empty which indicates that current color scheme will be used.")]
        public Color BackColor
        {
            get { return _BackColor; }
            set { _BackColor = value; }
        }
        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeBackColor()
        {
            return !_BackColor.IsEmpty;
        }
        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetBackColor()
        {
            this.BackColor = Color.Empty;
        }

        private Color _BorderColor = Color.Empty;
        /// <summary>
        /// Gets or sets the flyout border color. Default value of Color.Empty indicates that color scheme will be used.
        /// </summary>
        [Category("Columns"), Description("Indicates flyout border color. Default value of Color.Empty indicates that color scheme will be used.")]
        public Color BorderColor
        {
            get { return _BorderColor; }
            set { _BorderColor = value; }
        }
        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeBorderColor()
        {
            return !_BorderColor.IsEmpty;
        }
        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetBorderColor()
        {
            this.BorderColor = Color.Empty;
        }

        /// <summary>
        /// Indicates whether flyout displays drop shadow.
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates whether flyout displays drop shadow")]
        public bool DropShadow
        {
            get { return _DropShadow; }
            set
            {
                if (value != _DropShadow)
                {
                    bool oldValue = _DropShadow;
                    _DropShadow = value;
                    OnDropShadowChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when DropShadow property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnDropShadowChanged(bool oldValue, bool newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("DropShadow"));

        }

        private Control _Parent = null;
        /// <summary>
        /// Gets or sets the parent control for the Flyout. Parent is used to find the parent form so flyout can be closed when form is de-activated.
        /// </summary>
        [Browsable(false), DefaultValue(null)]
        public Control Parent
        {
            get { return _Parent; }
            set
            {
                if (value != _Parent)
                {
                    Control oldValue = _Parent;
                    _Parent = value;
                    OnParentChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Parent property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnParentChanged(Control oldValue, Control newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("Parent"));
        }
        #endregion

        #region IMessageHandlerClient
        private bool _MessageHandlerInstalled = false;
        bool IMessageHandlerClient.OnSysKeyDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return false;
        }

        bool IMessageHandlerClient.OnSysKeyUp(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return false;
        }

        bool IMessageHandlerClient.OnKeyDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return false;
        }

        bool IMessageHandlerClient.OnMouseDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            if ((_CloseMode & eFlyoutCloseMode.ClickOutside) == eFlyoutCloseMode.ClickOutside)
            {
                FlyoutForm form = _Flyout;
                if (form != null && form.Visible)
                {
                    if (!form.Bounds.Contains(Control.MousePosition))
                    {
                        // Ignore clicks on ComboBox popup
                        string s = NativeFunctions.GetClassName(hWnd);
                        s = s.ToLower();
                        if (s.IndexOf("combolbox") < 0)
                            Close();
                    }
                }
            }
            return false;
        }

        bool IMessageHandlerClient.OnMouseMove(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return false;
        }

        bool IMessageHandlerClient.OnMouseWheel(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return false;
        }

        bool IMessageHandlerClient.IsModal
        {
            get { return false; }
        }
        #endregion
    }
    /// <summary>
    /// Defines delegate for the FlyoutShowing event.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="ea"></param>
    public delegate void FlyoutShowingEventHandler(object sender, FlyoutShowingEventArgs e);
    public class FlyoutShowingEventArgs : EventArgs
    {
        /// <summary>
        /// Gets the reference to the flyout form.
        /// </summary>
        public FlyoutForm Flyout;
        /// <summary>
        /// Gets the reference to the flyout target usually TargetControl.
        /// </summary>
        public object Target;
        /// <summary>
        /// Allows you to cancel showing of the flyout by setting this value to true.
        /// </summary>
        public bool Cancel;
        /// <summary>
        /// Initializes a new instance of the FlyoutShowingEventArgs class.
        /// </summary>
        /// <param name="flyout"></param>
        /// <param name="target"></param>
        public FlyoutShowingEventArgs(FlyoutForm flyout, object target)
        {
            Flyout = flyout;
            Target = target;
        }
    }

    /// <summary>
    /// Defines the modes for Flyout display.
    /// </summary>
    public enum eFlyoutDisplayMode
    {
        /// <summary>
        /// Flyout is displayed manually using flyout.Show() method.
        /// </summary>
        Manual,
        /// <summary>
        /// Flyout is displayed when mouse is over TargetControl.
        /// </summary>
        MouseOver,
        /// <summary>
        /// Flyout is displayed when mouse is hovering over TargetControl.
        /// </summary>
        MouseHover,
        /// <summary>
        /// Flyout is displayed when left mouse button is clicked on TargetControl.
        /// </summary>
        MouseClick
    }

    /// <summary>
    /// Defines Flyout closing condition.
    /// </summary>
    [Flags()]
    public enum eFlyoutCloseMode
    {
        /// <summary>
        /// Flyout is closed manually using flyout.Close() method.
        /// </summary>
        Manual,
        /// <summary>
        /// Flyout is closed when user clicks outside of flyout bounds.
        /// </summary>
        ClickOutside,
        /// <summary>
        /// Flyout is closed when TargetControl is hidden.
        /// </summary>
        TargetControlHidden,
        /// <summary>
        /// Flyout is closed when TargetControl loses focus.
        /// </summary>
        TargetControlLostFocus,
        /// <summary>
        /// Flyout is closed when parent forms deactivates.
        /// </summary>
        ParentFormDeactivate
    }
}