using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using DevComponents.DotNetBar.Events;
using System.Collections;
using DevComponents.DotNetBar.Rendering;

namespace DevComponents.DotNetBar
{
    /// <summary>
    /// Defines Radial Menu control.
    /// </summary>
    [ToolboxItem(true), DefaultEvent("ItemClick"), System.Runtime.InteropServices.ComVisible(false), Designer("DevComponents.DotNetBar.Design.RadialMenuDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf"), ToolboxBitmap(typeof(ToolboxIconResFinder), "RadialMenu.ico")]
    public class RadialMenu : Control, IMessageHandlerClient, IOwner, IOwnerItemEvents
    {
        #region Constructor
        private RadialMenuContainer _MenuContainer = null;
        /// <summary>
        /// Initializes a new instance of the RadialMenu class.
        /// </summary>
        public RadialMenu()
        {
            _MenuContainer = new RadialMenuContainer();
            _MenuContainer.RadialMenu = this;
            _MenuContainer.Opened += new EventHandler(RadialMenuOpened);
            _MenuContainer.Closed += new EventHandler(RadialMenuClosed);

            this.SetStyle(
                ControlStyles.UserPaint |
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.Opaque |
                ControlStyles.ResizeRedraw |
                DisplayHelp.DoubleBufferFlag |
                ControlStyles.SupportsTransparentBackColor, true);
            _MenuContainer.SetOwner(this);
        }

        protected override void Dispose(bool disposing)
        {
            _MenuContainer.Dispose();
            base.Dispose(disposing);
        }
        private bool _AccessibleObjectCreated = false;
        protected override AccessibleObject CreateAccessibilityInstance()
        {
            _AccessibleObjectCreated = true;
            return new RadialMenuAccessibleObject(this);
        }
        #endregion

        #region Events
        /// <summary>
        /// Occurs before menu is closed and allows you to cancel closing.
        /// </summary>
        [Description("Occurs before menu is closed and allows you to cancel closing.")]
        public event CancelableEventSourceHandler BeforeMenuClose;
        /// <summary>
        /// Raises BeforeMenuClose event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnBeforeMenuClose(CancelableEventSourceArgs e)
        {
            CancelableEventSourceHandler handler = BeforeMenuClose;
            if (handler != null)
                handler(this, e);
        }
        /// <summary>
        /// Occurs before menu has been opened and allows you to cancel opening
        /// </summary>
        [Description("Occurs before menu has been opened and allows you to cancel opening.")]
        public event CancelableEventSourceHandler BeforeMenuOpen;
        /// <summary>
        /// Raises BeforeMenuOpen event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnBeforeMenuOpen(CancelableEventSourceArgs e)
        {
            CancelableEventSourceHandler handler = BeforeMenuOpen;
            if (handler != null)
                handler(this, e);
        }
        /// <summary>
        /// Occurs after menu has been opened.
        /// </summary>
        [Description("Occurs after menu has been opened.")]
        public event EventHandler MenuOpened;
        /// <summary>
        /// Raises MenuOpened event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnMenuOpened(EventArgs e)
        {
            EventHandler handler = MenuOpened;
            if (handler != null)
                handler(this, e);
        }
        /// <summary>
        /// Occurs after menu is closed.Occurs after menu is closed.
        /// </summary>
        [Description("Occurs after menu is closed.")]
        public event EventHandler MenuClosed;
        /// <summary>
        /// Raises MenuClosed event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnMenuClosed(EventArgs e)
        {
            EventHandler handler = MenuClosed;
            if (handler != null)
                handler(this, e);
        }
        #endregion

        #region Implementation
        /// <summary>
        /// Specifies the width of the sub-menu edge around the radial menu.
        /// </summary>
        [DefaultValue(18), Category("Appearance"), Description("Specifies the width of the sub-menu edge around the radial menu.")]
        public int SubMenuEdgeWidth
        {
            get { return _MenuContainer.SubMenuEdgeWidth; }
            set { _MenuContainer.SubMenuEdgeWidth = value; }
        }
        /// <summary>
        /// Indicates spacing between sub-menu marking edge and the item.
        /// </summary>
        [DefaultValue(3), Category("Appearance"), Description("Indicates spacing between sub-menu marking edge and the item.")]
        public int SubMenuEdgeItemSpacing
        {
            get { return _MenuContainer.SubMenuEdgeItemSpacing; }
            set { _MenuContainer.SubMenuEdgeItemSpacing = value; }
        }

        /// <summary>
        /// Gets or sets radial menu diameter. Minimum value is 64.
        /// </summary>
        [DefaultValue(180), Category("Appearance"), Description("Radial menu diameter.")]
        public int Diameter
        {
            get { return _MenuContainer.Diameter; }
            set { _MenuContainer.Diameter = value; }
        }

        /// <summary>
        /// Gets reference to colors used by the radial menu.
        /// </summary>
        [Category("Appearance"), Description("Gets reference to colors used by the radial menu."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public RadialMenuColorTable Colors
        {
            get
            {
                return _MenuContainer.Colors;
            }
        }

        /// <summary>
        /// Indicates the size of the back symbol that is displayed on center of radial menu
        /// </summary>
        [DefaultValue(18), Browsable(false), Description("Indicates the size of the back symbol that is displayed on center of radial menu")]
        public int BackButtonSymbolSize
        {
            get { return _MenuContainer.BackButtonSymbolSize; }
            set { _MenuContainer.BackButtonSymbolSize = value; }
        }

        /// <summary>
        /// Specifies the back button symbol.
        /// </summary>
        [DefaultValue("\uf060"), Category("Appearance"), Description("Specifies the back button symbol.")]
        [Editor("DevComponents.DotNetBar.Design.SymbolTypeEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor))]
        public string BackButtonSymbol
        {
            get { return _MenuContainer.BackButtonSymbol; }
            set { _MenuContainer.BackButtonSymbol = value; }
        }
        /// <summary>
        /// Gets or sets the symbol set used to represent the Symbol.
        /// </summary>
        [Browsable(false), DefaultValue(eSymbolSet.Awesome)]
        public eSymbolSet BackButtonSymbolSet
        {
            get { return _MenuContainer.BackButtonSymbolSet; }
            set
            {
                _MenuContainer.BackButtonSymbolSet = value;
            }
        }

        /// <summary>
        /// Indicates diameter of center button of radial menu.
        /// </summary>
        [DefaultValue(32), Category("Appearance"), Description("Indicates diameter of center button of radial menu.")]
        public int CenterButtonDiameter
        {
            get { return _MenuContainer.CenterButtonDiameter; }
            set { _MenuContainer.CenterButtonDiameter = value; }
        }

        /// <summary>
        /// Specifies the maximum pie part angle an item will occupy. Maximum is 180, minimum is 1 degree.
        /// </summary>
        [DefaultValue(90), Category("Appearance"), Description("Specifies the maximum pie part angle an item will occupy. Maximum is 180, minimum is 1 degree.")]
        public int MaxItemPieAngle
        {
            get { return _MenuContainer.MaxItemPieAngle; }
            set { _MenuContainer.MaxItemPieAngle = value; }
        }

        /// <summary>
        /// Indicates maximum radial angle single item in menu can consume. By default this property is set to zero which indicates that
        /// radial menu is equally divided between visible menu items.
        /// </summary>
        [DefaultValue(0), Category("Appearance"), Description("Indicates maximum radial angle single item in menu can consume. Max value is 180.")]
        public int MaxItemRadialAngle
        {
            get { return _MenuContainer.MaxItemRadialAngle; }
            set { _MenuContainer.MaxItemRadialAngle = value; }
        }

        /// <summary>
        /// Indicates the position of top-left corner of radial menu when shown in screen coordinates
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Category("Behavior"), Description("Indicates the position of top-left corner of radial menu when shown in screen coordinates")]
        public Point MenuLocation
        {
            get { return _MenuContainer.MenuLocation; }
            set { _MenuContainer.MenuLocation = value; }
        }

        /// <summary>
        /// Gets or sets whether radial menu is open.
        /// </summary>
        //[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //public bool IsMenuOpen
        //{
        //    get
        //    {
        //        return _MenuContainer.Expanded;
        //    }
        //    set
        //    {
        //        if (_MenuContainer.Expanded != value)
        //            _MenuContainer.Expanded = value;
        //    }
        //}

        private Image _Image = null;
        /// <summary>
        /// Indicates image displayed in center of the radial menu.
        /// </summary>
        [DefaultValue(null), Description("Indicates image displayed in center of the radial menu."), Category("Appearance")]
        public Image Image
        {
            get { return _Image; }
            set
            {
                if (value != _Image)
                {
                    Image oldValue = _Image;
                    _Image = value;
                    OnImageChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Image property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnImageChanged(Image oldValue, Image newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("Image"));
            this.Invalidate();
        }

        /// <summary>
        /// Indicates symbol displayed in center of the radial menu. When set, it overrides any Image settings.
        /// </summary>
        [DefaultValue(""), Description("Indicates image displayed in center of the radial menu.  When set, it overrides any Image settings."), Category("Appearance")]
        [Editor("DevComponents.DotNetBar.Design.SymbolTypeEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor))]
        public string Symbol
        {
            get { return _MenuContainer.Symbol; }
            set { _MenuContainer.Symbol = value; _SymbolTextSize = Size.Empty; this.Invalidate(); }
        }
        /// <summary>
        /// Gets or sets the symbol set used to represent the Symbol.
        /// </summary>
        [Browsable(false), DefaultValue(eSymbolSet.Awesome)]
        public eSymbolSet SymbolSet
        {
            get { return _MenuContainer.SymbolSet; }
            set
            {
                _MenuContainer.SymbolSet = value;
            }
        }

        /// <summary>
        /// Indicates the size of the symbol in points.
        /// </summary>
        [DefaultValue(0f), Category("Appearance"), Description("Indicates the size of the symbol in points.")]
        public float SymbolSize
        {
            get { return _MenuContainer.SymbolSize; }
            set { _MenuContainer.SymbolSize = value; _SymbolTextSize = Size.Empty; this.Invalidate(); }
        }

        private bool _IsOpen;
        /// <summary>
        /// Gets or sets whether radial menu is open.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsOpen
        {
            get { return _IsOpen; }
            set
            {
                if (value != _IsOpen)
                {
                    SetIsOpen(value, eEventSource.Code);
                }
            }
        }
        /// <summary>
        /// Called when IsOpen property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnIsOpenChanged(bool oldValue, bool newValue)
        {
            //OnPropertyChanged(new PropertyChangedEventArgs("IsOpen"));
        }
        /// <summary>
        /// Sets whether radial menu is open and provides the source of the action.
        /// </summary>
        /// <param name="isOpen">true to open menu, false to close it.</param>
        /// <param name="source">Source of the action.</param>
        public void SetIsOpen(bool isOpen, eEventSource source)
        {
            if (isOpen == _IsOpen) return;

            if (isOpen)
            {
                CancelableEventSourceArgs cancel = new CancelableEventSourceArgs(source);
                OnBeforeMenuOpen(cancel);
                if (cancel.Cancel) return;
            }
            else
            {
                CancelableEventSourceArgs cancel = new CancelableEventSourceArgs(source);
                OnBeforeMenuClose(cancel);
                if (cancel.Cancel) return;
            }

            bool oldValue = _IsOpen;
            _IsOpen = isOpen;
            _MenuContainer.Expanded = isOpen;
            OnIsOpenChanged(oldValue, isOpen);
        }
        /// <summary>
        /// Returns collection of items on a bar.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
        public SubItemsCollection Items
        {
            get
            {
                return _MenuContainer.SubItems;
            }
        }

        protected override void OnClick(EventArgs e)
        {
            SetIsOpen(!this.IsOpen, eEventSource.Mouse);
            base.OnClick(e);
        }

        private Size _SymbolTextSize = Size.Empty;
        private bool _Painting = false;
        protected override void OnPaint(PaintEventArgs e)
        {
            if (_Painting) return; // Stops painting when using transparent backgrounds since paint on parent paints this control too

            _Painting = true;
            try
            {
                RadialMenuColorTable renderTable = RadialMenuContainer.GetColorTable();
                RadialMenuColorTable localTable = _MenuContainer.Colors;

                Color symbolColor = ColorScheme.GetColor(0x2B579A);
                Color backColor = Color.White;

                if (!localTable.RadialMenuButtonBorder.IsEmpty)
                    symbolColor = localTable.RadialMenuButtonBorder;
                else if (renderTable != null && !renderTable.RadialMenuButtonBorder.IsEmpty)
                    symbolColor = renderTable.RadialMenuButtonBorder;

                if (!localTable.RadialMenuButtonBackground.IsEmpty)
                    backColor = localTable.RadialMenuButtonBackground;
                else if (renderTable != null && !renderTable.RadialMenuButtonBackground.IsEmpty)
                    backColor = renderTable.RadialMenuButtonBackground;

                SolidBrush backBrush = new SolidBrush(backColor);

                Graphics g = e.Graphics;

                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;

                Rectangle r = this.ClientRectangle;
                r.Inflate(1, 1);
                if (!this.BackColor.IsEmpty && this.BackColor != Color.Transparent)
                {
                    using (SolidBrush brush = new SolidBrush(this.BackColor))
                        g.FillRectangle(brush, r);
                }
                else if (this.BackColor == Color.Transparent)
                    PaintParentControlOnBackground(e.Graphics);

                r = this.ClientRectangle;
                r.Width--;
                r.Height--;

                Rectangle fill = r;
                fill.Inflate(-1, -1);
                g.FillEllipse(backBrush, fill);
                if (_SymbolBorderEnabled)
                {
                    using (GraphicsPath path = new GraphicsPath())
                    {
                        path.AddEllipse(r);
                        r.Inflate(-2, -2);
                        path.AddEllipse(r);
                        using (SolidBrush brush = new SolidBrush(symbolColor))
                            g.FillPath(brush, path);
                    }
                }

                if (!string.IsNullOrEmpty(_MenuContainer.SymbolRealized))
                {
                    float symbolSize = _MenuContainer.SymbolSize;
                    Font symFont = Symbols.GetFont(symbolSize, _MenuContainer.SymbolSet);
                    if (_SymbolTextSize.IsEmpty)
                    {
                        _SymbolTextSize = TextDrawing.MeasureStringLegacy(g, _MenuContainer.SymbolRealized, Symbols.GetFont(symbolSize, _MenuContainer.SymbolSet), Size.Empty, eTextFormat.Default);
                        int descent = (int)Math.Ceiling((symFont.FontFamily.GetCellDescent(symFont.Style) *
                        symFont.Size / symFont.FontFamily.GetEmHeight(symFont.Style)));
                        _SymbolTextSize.Height -= descent;
                    }

                    TextDrawing.DrawStringLegacy(g, _MenuContainer.SymbolRealized, Symbols.GetFont(symbolSize, _MenuContainer.SymbolSet),
                        symbolColor, new Rectangle(this.ClientRectangle.Width / 2, r.Y + (r.Height - _SymbolTextSize.Height) / 2, 0, 0),
                        eTextFormat.HorizontalCenter);
                }
                else if (_Image != null)
                {
                    r = this.ClientRectangle;
                    ImageHelper.DrawImageCenteredDpiAware(g, _Image, r);
                }

                backBrush.Dispose(); backBrush = null;
            }
            finally
            {
                _Painting = false;
            }
            base.OnPaint(e);
        }

        private void PaintParentControlOnBackground(Graphics g)
        {
            Control parent = this.Parent;
            if (parent != null)
            {
                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                using (Bitmap bmp = new Bitmap(parent.Width, parent.Height, g))
                {
                    parent.DrawToBitmap(bmp, parent.ClientRectangle);
                    g.TranslateTransform(-Left, -Top);
                    g.DrawImage(bmp, Point.Empty);
                    g.TranslateTransform(Left, Top);
                }
            }
        }

        private bool _SymbolBorderEnabled = true;

        /// <summary>
        /// Indicates whether border, a circle is rendered around the selected symbol which represents radial menu. Default value is true.
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates whether border, a circle is rendered around the selected symbol which represents radial menu.")]
        public bool SymbolBorderEnabled
        {
            get { return _SymbolBorderEnabled; }
            set { _SymbolBorderEnabled = value; this.Invalidate();}
        }

        protected override Size DefaultSize
        {
            get
            {
                return new Size(28, 28);
            }
        }
        public override System.Drawing.Size GetPreferredSize(System.Drawing.Size proposedSize)
        {
            if (proposedSize.Width <= 0) return new System.Drawing.Size(26, 26);

            return new System.Drawing.Size(proposedSize.Width, proposedSize.Height);
        }

        void RadialMenuClosed(object sender, EventArgs e)
        {
            _IsOpen = false;
            RaiseAccessibilityEvent(AccessibleEvents.SystemMenuPopupEnd);
            RaiseAccessibilityEvent(AccessibleEvents.SystemMenuEnd);
            OnMenuClosed(EventArgs.Empty);
        }

        private void RadialMenuOpened(object sender, EventArgs e)
        {
            RaiseAccessibilityEvent(AccessibleEvents.SystemMenuStart);
            RaiseAccessibilityEvent(AccessibleEvents.SystemMenuPopupStart);
            OnMenuOpened(EventArgs.Empty);
        }

        private void RaiseAccessibilityEvent(AccessibleEvents e)
        {
            if (!_AccessibleObjectCreated) return;
            RadialMenuAccessibleObject acc = (RadialMenuAccessibleObject)this.AccessibilityObject;
            acc.GenerateEvent(e);
        }

        private bool _ShortcutsEnabled = true;
        /// <summary>
        /// Gets or sets whether shortcut processing for the items hosted by this control is enabled. Default value is true.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ShortcutsEnabled
        {
            get { return _ShortcutsEnabled; }
            set { _ShortcutsEnabled = value; }
        }

        private bool _CloseMenuOnAppDeactivate = true;
        /// <summary>
        /// Indicates whether radial menu is closed automatically when app is deactivated. Default value is true, if set to false
        /// you are responsible for closing the menu.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether radial menu is closed automatically when app is deactivated"), Browsable(false)]
        public bool CloseMenuOnAppDeactivate
        {
            get { return _CloseMenuOnAppDeactivate; }
            set
            {
                _CloseMenuOnAppDeactivate = value;
            }
        }

        private bool _UseHook = false;
        /// <summary>
        /// Gets or sets whether hooks are used for internal DotNetBar system functionality. Using hooks is recommended only if DotNetBar is used in hybrid environments like Visual Studio designers or IE.
        /// </summary>
        [Browsable(false), DefaultValue(false), Category("Behavior"), Description("Gets or sets whether hooks are used for internal DotNetBar system functionality. Using hooks is recommended only if DotNetBar is used in hybrid environments like Visual Studio designers or IE.")]
        public bool UseHook
        {
            get
            {
                return _UseHook;
            }
            set
            {
                _UseHook = value;
            }
        }

        private bool _MenuEventSupport = false;
        private Hook _Hook = null;
        private bool _FilterInstalled = false;
        protected override void OnHandleCreated(EventArgs e)
        {
            if (!_FilterInstalled && !this.DesignMode)
            {
                MessageHandler.RegisterMessageClient(this);
                _FilterInstalled = true;
            }

            if (!this.GetDesignMode() && !_UseHook)
            {
                if (!_MenuEventSupport)
                    MenuEventSupportHook();
            }
            else
            {
                if (_Hook == null)
                {
                    _Hook = new Hook(this);
                }
            }

            UpdateScaleFactor();
            base.OnHandleCreated(e);
        }
        protected override void OnHandleDestroyed(EventArgs e)
        {
            MenuEventSupportUnhook();

            base.OnHandleDestroyed(e);

            if (_FilterInstalled)
            {
                MessageHandler.UnregisterMessageClient(this);
                _FilterInstalled = false;
            }

            if (_Hook != null)
            {
                _Hook.Dispose();
                _Hook = null;
            }
        }
        private void MenuEventSupportUnhook()
        {
            if (!_MenuEventSupport)
                return;
            _MenuEventSupport = false;

            Form parentForm = this.FindForm();
            if (parentForm == null)
                return;
            if (parentForm.IsMdiChild && parentForm.MdiParent != null)
                parentForm = parentForm.MdiParent;

            DotNetBarManager.UnRegisterParentMsgHandler(this, parentForm);
            parentForm.Resize -= new EventHandler(this.ParentResize);
            parentForm.Deactivate -= new EventHandler(this.ParentDeactivate);
        }

        /// <summary>
        /// Indicates the radial menu type. eRadialMenuType.Segment menu type allows for display of image, text and any sub-menu items.
        /// eRadialMenuType.Circular allows only for display of Symbol or Image and it does not display either text or sub-menu items. 
        /// eRadialMenuType.Circular is designed to be used for single level menus only that don't need text.
        /// </summary>
        [DefaultValue(eRadialMenuType.Segment), Category("Appearance"), Description("Indicates the radial menu type.")]
        public eRadialMenuType MenuType
        {
            get { return _MenuContainer.MenuType; }
            set { _MenuContainer.MenuType = value; }
        }

        private bool _AutoScale = true;
        /// <summary>
        /// Indicates whether control automatically scales the items if the parent Form performs scaling due to AutoScale settings.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether control automatically scales the items if the parent Form performs scaling due to AutoScale settings.")]
        public bool AutoScale
        {
            get { return _AutoScale; }
            set
            {
                _AutoScale = value;
                UpdateScaleFactor();
            }
        }

        private void UpdateScaleFactor()
        {
            if (!this.IsHandleCreated)
                return;
            if (_AutoScale)
            {
                using (Graphics g = this.CreateGraphics())
                {
                    SizeF factor = new SizeF(g.DpiX / 96, g.DpiY / 96);
                    if (factor.Width != 1f)
                        _MenuContainer.ScaleFactor = factor;
                }
            }
            else
                _MenuContainer.ScaleFactor = new SizeF(1, 1);
        }

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == (int)WinApi.WindowsMessages.WM_DPICHANGED)
                UpdateScaleFactor();
            base.WndProc(ref m);
        }

        private string _AccessibleHelp = "";
        /// <summary>
        /// Indicates accessibility help string
        /// </summary>
        [DefaultValue(""), Category("Accessibility"), Description("Indicates accessibility help string")]
        public string AccessibleHelp
        {
            get { return _AccessibleHelp; }
            set
            {
                _AccessibleHelp = value;
            }
        }
        
        #endregion

        #region IMessageHandlerClient Implementation
        bool IMessageHandlerClient.IsModal
        {
            get
            {
                Form form = this.FindForm();
                if (form != null)
                    return form.Modal;
                return false;
            }
        }

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

        protected virtual bool OnMouseWheel(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return false;
        }

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

        /// <summary>
        /// Returns whether control has any popups registered.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        public bool HasRegisteredPopups
        {
            get
            {
                return _MenuContainer.Expanded;
            }
        }

        #region OnKeyDown
        private bool _DesignModeInternal = false;
        protected bool GetDesignMode()
        {
            if (!_DesignModeInternal)
                return this.DesignMode;
            return _DesignModeInternal;
        }
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public void SetDesignMode(bool mode)
        {
            _DesignModeInternal = mode;
            _MenuContainer.SetDesignMode(mode);
        }
        protected virtual bool OnKeyDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            bool designMode = this.GetDesignMode();

            int wParamInt = WinApi.ToInt(wParam);

            if (_MenuContainer.Expanded && wParamInt == 27) // Escape
            {
                this.SetIsOpen(false, eEventSource.Keyboard);
                return true;
            }
            if (_MenuContainer.Expanded && _MenuContainer.Popup != null && _MenuContainer.Popup.Handle == hWnd)
            {
                Keys key = (Keys)NativeFunctions.MapVirtualKey((uint)wParam, 2);
                if (key == Keys.None)
                    key = (Keys)wParamInt;
                _MenuContainer.InternalKeyDown(new KeyEventArgs(key));
                return false;
            }

            if (!this.IsParentFormActive)
                return false;

            if (wParamInt >= 0x70 || ModifierKeys != Keys.None || (WinApi.ToInt(lParam) & 0x1000000000) != 0 || wParamInt == 0x2E || wParamInt == 0x2D) // 2E=VK_DELETE, 2D=VK_INSERT
            {
                int i = (int)ModifierKeys | wParamInt;
                return ProcessShortcut((eShortcut)i) && !designMode;
            }
            return false;
        }
        #endregion

        private bool _DispatchShortcuts = false;
        /// <summary>
        /// Indicates whether shortcuts handled by items are dispatched to the next handler or control.
        /// </summary>
        [Browsable(false), DefaultValue(false), Category("Behavior"), Description("Indicates whether shortucts handled by items are dispatched to the next handler or control.")]
        public bool DispatchShortcuts
        {
            get { return _DispatchShortcuts; }
            set { _DispatchShortcuts = value; }
        }
        private bool ProcessShortcut(eShortcut key)
        {
            if (!_ShortcutsEnabled || !this.Enabled) return false;

            Form form = this.FindForm();
            if (form == null || (form != Form.ActiveForm && form.MdiParent == null ||
                form.MdiParent != null && form.MdiParent.ActiveMdiChild != form) && !form.IsMdiContainer || Form.ActiveForm != null && Form.ActiveForm.Modal && Form.ActiveForm != form)
                return false;

            bool eat = BarFunctions.ProcessItemsShortcuts(key, _ShortcutTable);
            return !_DispatchShortcuts && eat;
        }
        protected bool IsParentFormActive
        {
            get
            {
                // Process only if parent form is active
                Form form = this.FindForm();
                if (form == null)
                    return false;
                if (form.IsMdiChild)
                {
                    if (form.MdiParent == null)
                        return false;
                    if (form.MdiParent.ActiveMdiChild != form)
                        return false;
                }
                else if (form != Form.ActiveForm)
                    return false;
                return true;
            }
        }

        private PopupDelayedClose m_DelayClose = null;
        private PopupDelayedClose GetDelayClose()
        {
            if (m_DelayClose == null)
                m_DelayClose = new PopupDelayedClose();
            return m_DelayClose;
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void DesignerNewItemAdded()
        {
            this.GetDelayClose().EraseDelayClose();
        }
        private ArrayList _RegisteredPopups = new ArrayList();
        protected virtual bool OnSysMouseDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            if (!_IsOpen || this.GetDesignMode() || _MenuContainer.Popup == null)
                return false;

            if (!_MenuContainer.Popup.Bounds.Contains(MousePosition))
            {
                SetIsOpen(false, eEventSource.Mouse);
            }

            return false;
        }
        bool IMessageHandlerClient.OnMouseDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return OnSysMouseDown(hWnd, wParam, lParam);
        }
        bool IMessageHandlerClient.OnMouseMove(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            if (_IsOpen && _MenuContainer.Popup != null && _MenuContainer.Popup.Handle != hWnd) return true; // Eat mouse messages for other windows while popup is open
            return false;
        }
        bool IMessageHandlerClient.OnSysKeyDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return OnSysKeyDown(hWnd, wParam, lParam);
        }

        protected virtual bool OnSysKeyDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            if (!this.GetDesignMode())
            {
                int wParamInt = WinApi.ToInt(wParam);
                if (wParamInt == 18 && System.Windows.Forms.Control.ModifierKeys == System.Windows.Forms.Keys.Alt)
                    this.SetIsOpen(false, eEventSource.Keyboard);

                // Check Shortcuts
                if (ModifierKeys != Keys.None || wParamInt >= (int)eShortcut.F1 && wParamInt <= (int)eShortcut.F12)
                {
                    int i = (int)ModifierKeys | wParamInt;
                    if (ProcessShortcut((eShortcut)i))
                        return true;
                }
            }
            return false;
        }

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

        protected virtual bool OnSysKeyUp(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            return false;
        }
        private void MenuEventSupportHook()
        {
            if (_MenuEventSupport)
                return;
            _MenuEventSupport = true;

            Form parentForm = this.FindForm();
            if (parentForm == null)
            {
                _MenuEventSupport = false;
                return;
            }

            if (parentForm.IsMdiChild && parentForm.MdiParent != null)
                parentForm = parentForm.MdiParent;

            parentForm.Resize += new EventHandler(this.ParentResize);
            parentForm.Deactivate += new EventHandler(this.ParentDeactivate);

            DotNetBarManager.RegisterParentMsgHandler(this, parentForm);
        }

        private void ParentResize(object sender, EventArgs e)
        {
            Form parentForm = this.FindForm();
            if (parentForm != null && parentForm.WindowState == FormWindowState.Minimized)
                ((IOwner)this).OnApplicationDeactivate();
        }
        private void ParentDeactivate(object sender, EventArgs e)
        {
            Form parentForm = this.FindForm();
            if (parentForm != null && parentForm.WindowState == FormWindowState.Minimized)
                ((IOwner)this).OnApplicationDeactivate();
        }
        #endregion

        #region IOwner Members

        Form IOwner.ParentForm
        {
            get
            {
                return base.FindForm();
            }
            set { }
        }
        /// <summary>
        /// Returns the collection of items with the specified name.
        /// </summary>
        /// <param name="ItemName">Item name to look for.</param>
        /// <returns></returns>
        System.Collections.ArrayList IOwner.GetItems(string ItemName)
        {
            ArrayList list = new ArrayList(15);
            BarFunctions.GetSubItemsByName(_MenuContainer, ItemName, list);
            return list;
        }
        /// <summary>
        /// Returns the collection of items with the specified name and type.
        /// </summary>
        /// <param name="ItemName">Item name to look for.</param>
        /// <param name="itemType">Item type to look for.</param>
        /// <returns></returns>
        System.Collections.ArrayList IOwner.GetItems(string ItemName, Type itemType)
        {
            ArrayList list = new ArrayList(15);
            BarFunctions.GetSubItemsByNameAndType(_MenuContainer, ItemName, list, itemType);
            return list;
        }
        /// <summary>
        /// Returns the collection of items with the specified name and type.
        /// </summary>
        /// <param name="ItemName">Item name to look for.</param>
        /// <param name="itemType">Item type to look for.</param>
        /// <param name="useGlobalName">Indicates whether GlobalName property is used for searching.</param>
        /// <returns></returns>
        System.Collections.ArrayList IOwner.GetItems(string ItemName, Type itemType, bool useGlobalName)
        {
            ArrayList list = new ArrayList(15);
            BarFunctions.GetSubItemsByNameAndType(_MenuContainer, ItemName, list, itemType, useGlobalName);
            return list;
        }
        /// <summary>
        /// Returns the first item that matches specified name.
        /// </summary>
        /// <param name="ItemName">Item name to look for.</param>
        /// <returns></returns>
        BaseItem IOwner.GetItem(string ItemName)
        {
            BaseItem item = BarFunctions.GetSubItemByName(_MenuContainer, ItemName);
            if (item != null)
                return item;
            return null;
        }

        private BaseItem _ExpandedItem = null;
        void IOwner.SetExpandedItem(BaseItem objItem)
        {
            if (objItem != null && (objItem.Parent is RadialMenuContainer || objItem.Parent is RadialMenu))
                return;
            if (_ExpandedItem != null)
            {
                if (_ExpandedItem.Expanded)
                    _ExpandedItem.Expanded = false;
                _ExpandedItem = null;
            }
            _ExpandedItem = objItem;
        }

        BaseItem IOwner.GetExpandedItem()
        {
            return _ExpandedItem;
        }

        private BaseItem _FocusItem = null;
        // Currently we are using this to communicate "focus" when control is in
        // design mode. This can be used later if we decide to add focus
        // handling to our BaseItem class.
        void IOwner.SetFocusItem(BaseItem objFocusItem)
        {
            if (_FocusItem != null && _FocusItem != objFocusItem)
            {
                _FocusItem.OnLostFocus();
            }
            OnSetFocusItem(objFocusItem);
            _FocusItem = objFocusItem;
            if (_FocusItem != null)
                _FocusItem.OnGotFocus();
        }
        protected virtual void OnSetFocusItem(BaseItem objFocusItem)
        {
        }
        BaseItem IOwner.GetFocusItem()
        {
            return _FocusItem;
        }

        void IOwner.DesignTimeContextMenu(BaseItem objItem) { }

        private Hashtable _ShortcutTable = new Hashtable();
        void IOwner.RemoveShortcutsFromItem(BaseItem objItem)
        {
            ShortcutTableEntry objEntry = null;
            if (objItem.ShortcutString != "")
            {
                foreach (eShortcut key in objItem.Shortcuts)
                {
                    if (_ShortcutTable.ContainsKey(key))
                    {
                        objEntry = (ShortcutTableEntry)_ShortcutTable[key];
                        try
                        {
                            objEntry.Items.Remove(objItem.Id);
                            if (objEntry.Items.Count == 0)
                                _ShortcutTable.Remove(objEntry.Shortcut);
                        }
                        catch (ArgumentException) { }
                    }
                }
            }
            IOwner owner = this as IOwner;
            foreach (BaseItem objTmp in objItem.SubItems)
                owner.RemoveShortcutsFromItem(objTmp);
        }

        void IOwner.AddShortcutsFromItem(BaseItem objItem)
        {
            ShortcutTableEntry objEntry = null;
            if (objItem.ShortcutString != "")
            {
                foreach (eShortcut key in objItem.Shortcuts)
                {
                    if (_ShortcutTable.ContainsKey(key))
                        objEntry = (ShortcutTableEntry)_ShortcutTable[objItem.Shortcuts[0]];
                    else
                    {
                        objEntry = new ShortcutTableEntry(key);
                        _ShortcutTable.Add(objEntry.Shortcut, objEntry);
                    }
                    try
                    {
                        objEntry.Items.Add(objItem.Id, objItem);
                    }
                    catch (ArgumentException) { }
                }
            }
            IOwner owner = this as IOwner;
            foreach (BaseItem objTmp in objItem.SubItems)
                owner.AddShortcutsFromItem(objTmp);
        }

        ImageList IOwner.Images
        {
            get { return null; }
            set { }
        }

        ImageList IOwner.ImagesMedium
        {
            get { return null; }
            set { }
        }

        ImageList IOwner.ImagesLarge
        {
            get { return null; }
            set { }
        }

        void IOwner.StartItemDrag(BaseItem objItem)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        BaseItem IOwner.DragItem
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        bool IOwner.DragInProgress
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        private bool _ShowToolTips = true;
        /// <summary>
        /// Indicates whether items show tooltips.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether items show tooltips.")]
        public bool ShowToolTips
        {
            get
            {
                return _ShowToolTips;
            }
            set
            {
                _ShowToolTips = value;
            }
        }

        private bool _ShowShortcutKeysInToolTips = false;
        /// <summary>
        /// Indicates whether item shortcut is displayed in Tooltips.
        /// </summary>
        [Browsable(true), DefaultValue(false), Category("Behavior"), Description("Indicates whether item shortcut is displayed in Tooltips.")]
        public virtual bool ShowShortcutKeysInToolTips
        {
            get
            {
                return _ShowShortcutKeysInToolTips;
            }
            set
            {
                _ShowShortcutKeysInToolTips = value;
            }
        }


        private bool _AlwaysDisplayKeyAccelerators = false;
        /// <summary>
        /// Gets or sets whether accelerator letters on buttons are underlined. Default value is false which indicates that system setting is used
        /// to determine whether accelerator letters are underlined. Setting this property to true
        /// will always display accelerator letter underlined.
        /// </summary>
        [Browsable(true), DefaultValue(false), Category("Behavior"), Description("Indicates whether accelerator letters for buttons are underlined regardless of current Windows settings.")]
        public bool AlwaysDisplayKeyAccelerators
        {
            get { return _AlwaysDisplayKeyAccelerators; }
            set
            {
                if (_AlwaysDisplayKeyAccelerators != value)
                {
                    _AlwaysDisplayKeyAccelerators = value;
                    this.Invalidate();
                }
            }
        }

        Form IOwner.ActiveMdiChild
        {
            get
            {
                Form form = base.FindForm();
                if (form == null)
                    return null;
                if (form.IsMdiContainer)
                {
                    return form.ActiveMdiChild;
                }
                return null;
            }
        }

        MdiClient IOwner.GetMdiClient(Form MdiForm)
        {
            return BarFunctions.GetMdiClient(MdiForm);
        }

        void IOwner.Customize()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        void IOwner.InvokeResetDefinition(BaseItem item, EventArgs e)
        {

        }

        bool IOwner.ShowResetButton
        {
            get
            {
                return false;
            }
            set
            {
                throw new Exception("The method or operation is not implemented.");
            }
        }

        void IOwner.InvokeDefinitionLoaded(object sender, EventArgs e)
        {

        }

        void IOwner.InvokeUserCustomize(object sender, EventArgs e)
        {

        }

        void IOwner.InvokeEndUserCustomize(object sender, EndUserCustomizeEventArgs e)
        {

        }

        void IOwner.OnApplicationActivate()
        {

        }

        void IOwner.OnApplicationDeactivate()
        {
            if (this.IsOpen && _CloseMenuOnAppDeactivate) this.IsOpen = false;
        }

        void IOwner.OnParentPositionChanging()
        {
            if (this.IsOpen) this.IsOpen = false;
        }

        bool IOwner.DesignMode
        {
            get { return this.DesignMode; }
        }

        private bool _DisabledImagesGrayScale = true;
        /// <summary>
        /// Gets or sets whether gray-scale algorithm is used to create automatic gray-scale images. Default is true.
        /// </summary>
        [Browsable(true), DefaultValue(true), Category("Appearance"), Description("Gets or sets whether gray-scale algorithm is used to create automatic gray-scale images.")]
        public bool DisabledImagesGrayScale
        {
            get
            {
                return _DisabledImagesGrayScale;
            }
            set
            {
                _DisabledImagesGrayScale = value;
            }
        }
        #endregion

        #region IOwnerItemEvents Members
        /// <summary>
        /// Occurs after an item has been added to items collection.
        /// </summary>
        [Description("Occurs after an item has been added to items collection.")]
        public event EventHandler ItemAdded;
        /// <summary>
        /// Raises ItemAdded event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemAdded(BaseItem source, EventArgs e)
        {
            EventHandler handler = ItemAdded;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeItemAdded(BaseItem item, EventArgs e)
        {
            OnItemAdded(item, e);
        }

        /// <summary>
        /// Occurs after an item has been removed from items collection.
        /// </summary>
        [Description("Occurs after an item has been removed from items collection.")]
        public event DevComponents.DotNetBar.ItemControl.ItemRemovedEventHandler ItemRemoved;
        /// <summary>
        /// Raises ItemRemoved event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemRemoved(BaseItem source, ItemRemovedEventArgs e)
        {
            DevComponents.DotNetBar.ItemControl.ItemRemovedEventHandler handler = ItemRemoved;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeItemRemoved(BaseItem item, BaseItem parent, int itemIndex)
        {
            OnItemRemoved(item, new ItemRemovedEventArgs(parent, itemIndex));
        }

        /// <summary>
        /// Occurs when mouse pointer enters boundaries of an item.
        /// </summary>
        [Description("Occurs when mouse pointer enters boundaries of an item.")]
        public event EventHandler ItemMouseEnter;
        /// <summary>
        /// Raises ItemMouseEnter event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemMouseEnter(BaseItem source, EventArgs e)
        {
            EventHandler handler = ItemMouseEnter;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeMouseEnter(BaseItem item, EventArgs e)
        {
            OnItemMouseEnter(item, e);
        }

        /// <summary>
        /// Occurs when mouse pointer hovers over an item.
        /// </summary>
        [Description("Occurs when mouse pointer hovers over an item.")]
        public event EventHandler ItemMouseHover;
        /// <summary>
        /// Raises ItemMouseHover event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemMouseHover(BaseItem source, EventArgs e)
        {
            EventHandler handler = ItemMouseHover;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeMouseHover(BaseItem item, EventArgs e)
        {
            OnItemMouseHover(item, e);
        }

        /// <summary>
        /// Occurs when mouse pointer leaves boundaries of an item.
        /// </summary>
        [Description("Occurs when mouse pointer leaves boundaries of an item.")]
        public event EventHandler ItemMouseLeave;
        /// <summary>
        /// Raises ItemMouseLeave event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemMouseLeave(BaseItem source, EventArgs e)
        {
            EventHandler handler = ItemMouseLeave;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeMouseLeave(BaseItem item, EventArgs e)
        {
            OnItemMouseLeave(item, e);
        }

        /// <summary>
        /// Occurs when mouse button is pressed on item.
        /// </summary>
        [Description("Occurs when mouse button is pressed on item.")]
        public event MouseEventHandler ItemMouseDown;
        /// <summary>
        /// Raises ItemMouseDown event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemMouseDown(BaseItem source, MouseEventArgs e)
        {
            MouseEventHandler handler = ItemMouseDown;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeMouseDown(BaseItem item, MouseEventArgs e)
        {
            OnItemMouseDown(item, e);
        }

        /// <summary>
        /// Occurs when mouse button is released on item.
        /// </summary>
        [Description("Occurs when mouse button is released on item.")]
        public event MouseEventHandler ItemMouseUp;
        /// <summary>
        /// Raises ItemMouseUp event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemMouseUp(BaseItem source, MouseEventArgs e)
        {
            MouseEventHandler handler = ItemMouseUp;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeMouseUp(BaseItem item, MouseEventArgs e)
        {
            OnItemMouseUp(item, e);
        }

        /// <summary>
        /// Occurs when mouse moves over an item.
        /// </summary>
        [Description("Occurs when mouse moves over an item.")]
        public event MouseEventHandler ItemMouseMove;
        /// <summary>
        /// Raises ItemMouseMove event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemMouseMove(BaseItem source, MouseEventArgs e)
        {
            MouseEventHandler handler = ItemMouseMove;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeMouseMove(BaseItem item, MouseEventArgs e)
        {
            OnItemMouseMove(item, e);
        }

        /// <summary>
        /// Occurs when an item is clicked.
        /// </summary>
        [Description("Occurs when an item is clicked.")]
        public event EventHandler ItemClick;
        /// <summary>
        /// Raises ItemClick event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemClick(BaseItem source, EventArgs e)
        {
            EventHandler handler = ItemClick;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeItemClick(BaseItem objItem)
        {
            OnItemClick(objItem, EventArgs.Empty);
        }

        /// <summary>
        /// Occurs when an item is double-clicked.
        /// </summary>
        [Description("Occurs when an item is double-clicked.")]
        public event MouseEventHandler ItemDoubleClick;
        /// <summary>
        /// Raises ItemDoubleClick event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemDoubleClick(BaseItem source, MouseEventArgs e)
        {
            MouseEventHandler handler = ItemDoubleClick;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeItemDoubleClick(BaseItem objItem, MouseEventArgs e)
        {
            OnItemDoubleClick(objItem, e);
        }

        void IOwnerItemEvents.InvokeGotFocus(BaseItem item, EventArgs e)
        {

        }

        void IOwnerItemEvents.InvokeLostFocus(BaseItem item, EventArgs e)
        {

        }

        /// <summary>
        /// Occurs when an item Expanded property value has changed.
        /// </summary>
        [Description("Occurs when an item Expanded property value has changed.")]
        public event EventHandler ItemExpandedChanged;
        /// <summary>
        /// Raises ItemExpandedChanged event.
        /// </summary>
        /// <param name="source">Reference to item.</param>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemExpandedChanged(BaseItem source, EventArgs e)
        {
            EventHandler handler = ItemExpandedChanged;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeExpandedChange(BaseItem item, EventArgs e)
        {
            OnItemExpandedChanged(item, e);
        }

        /// <summary>
        /// Occurs when an item Text property value has changed.
        /// </summary>
        [Description("Occurs when an item Text property value has changed.")]
        public event EventHandler ItemTextChanged;
        /// <summary>
        /// Raises ItemTextChanged event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemTextChanged(BaseItem source, EventArgs e)
        {
            EventHandler handler = ItemTextChanged;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeItemTextChanged(BaseItem item, EventArgs e)
        {
            OnItemTextChanged(item, e);
        }

        void IOwnerItemEvents.InvokeContainerControlDeserialize(BaseItem item, ControlContainerSerializationEventArgs e)
        {

        }

        void IOwnerItemEvents.InvokeContainerControlSerialize(BaseItem item, ControlContainerSerializationEventArgs e)
        {

        }

        void IOwnerItemEvents.InvokeContainerLoadControl(BaseItem item, EventArgs e)
        {

        }

        void IOwnerItemEvents.InvokeOptionGroupChanging(BaseItem item, OptionGroupChangingEventArgs e)
        {

        }

        /// <summary>
        /// Occurs when tooltip for an item is about to be displayed.
        /// </summary>
        [Description("Occurs when tooltip for an item is about to be displayed.")]
        public event EventHandler ItemTooltipShowing;
        /// <summary>
        /// Raises ItemTooltipShowing event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnItemTooltipShowing(object source, EventArgs e)
        {
            EventHandler handler = ItemTooltipShowing;
            if (handler != null)
                handler(source, e);
        }
        void IOwnerItemEvents.InvokeToolTipShowing(object item, EventArgs e)
        {
            OnItemTooltipShowing(item, e);
        }

        void IOwnerItemEvents.InvokeCheckedChanged(ButtonItem item, EventArgs e)
        {

        }

        #endregion

        #region RadialMenuAccessibleObject
        public class RadialMenuAccessibleObject : System.Windows.Forms.Control.ControlAccessibleObject
        {
            RadialMenu _Owner = null;
            public RadialMenuAccessibleObject(RadialMenu owner)
                : base(owner)
            {
                _Owner = owner;
            }

            internal void GenerateEvent(BaseItem sender, System.Windows.Forms.AccessibleEvents e)
            {
                int iChild = _Owner.Items.IndexOf(sender);
                if (iChild >= 0)
                {
                    if (_Owner != null && !_Owner.IsDisposed)
                        _Owner.AccessibilityNotifyClients(e, iChild);
                }
            }

            internal void GenerateEvent(System.Windows.Forms.AccessibleEvents e)
            {
                if (_Owner == null)
                    return;
                _Owner.AccessibilityNotifyClients(e, -1);
            }

            public override AccessibleRole Role
            {
                get
                {
                    if (_Owner != null && !_Owner.IsDisposed)
                        return _Owner.AccessibleRole;
                    return System.Windows.Forms.AccessibleRole.None;
                }
            }

            public override AccessibleObject Parent
            {
                get
                {
                    if (_Owner != null && !_Owner.IsDisposed)
                        return _Owner.Parent.AccessibilityObject;
                    return null;
                }
            }

            public override Rectangle Bounds
            {
                get
                {
                    if (_Owner != null && !_Owner.IsDisposed && _Owner.Parent != null)
                    {
                        return this._Owner.Parent.RectangleToScreen(_Owner.Bounds);
                    }
                    return Rectangle.Empty;
                }
            }

            public override int GetChildCount()
            {
                if (_Owner != null && !_Owner.IsDisposed && _Owner.Items != null)
                    return _Owner.Items.Count;
                return 0;
            }

            public override System.Windows.Forms.AccessibleObject GetChild(int iIndex)
            {
                if (_Owner != null && !_Owner.IsDisposed && _Owner.Items != null)
                    return _Owner.Items[iIndex].AccessibleObject;
                return null;
            }

            public override AccessibleStates State
            {
                get
                {
                    AccessibleStates state = AccessibleStates.Default;
                    if (_Owner == null || _Owner.IsDisposed)
                        return AccessibleStates.None;
                    if (_Owner.Focused)
                        state = AccessibleStates.Focused;
                    if (_Owner.IsOpen)
                        state = AccessibleStates.Expanded;

                    return state;
                }
            }

            public override string DefaultAction
            {
                get
                {
                    if (!string.IsNullOrEmpty(_Owner.AccessibleDefaultActionDescription))
                        return _Owner.AccessibleDefaultActionDescription;
                    return "Open";
                }
            }

            public override string Description
            {
                get
                {
                    if (!string.IsNullOrEmpty(_Owner.AccessibleDescription))
                        return _Owner.AccessibleDescription;
                    return "Radial Menu";
                }
            }

            public override void DoDefaultAction() 
            {
                if (_Owner != null && !_Owner.IsDisposed)
                    _Owner.IsOpen = !_Owner.IsOpen;
            }

            public override string Help
            {
                get
                {
                    if (!string.IsNullOrEmpty(_Owner.AccessibleHelp))
                        return _Owner.AccessibleHelp;
                    return "";
                }
            }

            public override string Name
            {
                get
                {
                    return _Owner.Name;
                }
                set
                {
                    _Owner.Name = value;
                }
            }

            public override string Value
            {
                get
                {
                    return _Owner.Text;
                }
                set
                {
                    _Owner.Text = value;
                }
            }

            public override string KeyboardShortcut
            {
                get
                {
                    return "";
                }
            }
        }
        #endregion
    }
}