using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Collections;
using DevComponents.DotNetBar.Metro.Rendering;
using DevComponents.DotNetBar.Rendering;

namespace DevComponents.DotNetBar.Metro
{
    /// <summary>
    /// Represents Metro-UI TabStrip control.
    /// </summary>
    [ToolboxItem(false), ComVisible(false)]
    public class MetroTabStrip : ItemControl
    {
        #region Private Variables & Constructor
        private MetroStripContainerItem _StripContainer = null;
        private int _CaptionHeight = 0;
        private bool _CaptionVisible = false;
        private Rectangle _CaptionBounds = Rectangle.Empty;
        private Rectangle _QuickToolbarBounds = Rectangle.Empty;
        private Rectangle _SystemCaptionItemBounds = Rectangle.Empty;
        private Font _CaptionFont = null;
        private bool _CanCustomize = true;
        private ElementStyle _DefaultBackgroundStyle = new ElementStyle();
        private bool _KeyTipsEnabled = true;
        private string _TitleText = "";

        public MetroTabStrip()
        {
            this.SetStyle(ControlStyles.StandardDoubleClick, true);

            _StripContainer = new MetroStripContainerItem(this);
            _StripContainer.GlobalItem = false;
            _StripContainer.ContainerControl = this;
            _StripContainer.Displayed = true;
            _StripContainer.SetOwner(this);
            _StripContainer.Style = eDotNetBarStyle.Metro;
            this.SetBaseItemContainer(_StripContainer);

            this.ColorScheme.Style = eDotNetBarStyle.Office2003;

            this.AutoSize = true;

            // Setup system caption item
            _StripContainer.SystemCaptionItem.Click += new EventHandler(SystemCaptionClick);

            StyleManager.Register(this);
        }
        protected override void Dispose(bool disposing)
        {
            StyleManager.Unregister(this);
            base.Dispose(disposing);
        }
        /// <summary>
        /// Called by StyleManager to notify control that style on manager has changed and that control should refresh its appearance if
        /// its style is controlled by StyleManager.
        /// </summary>
        /// <param name="newStyle">New active style.</param>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void StyleManagerStyleChanged(eDotNetBarStyle newStyle)
        {
            this.Style = StyleManager.GetEffectiveStyle();
        }
        #endregion

        #region Events
        /// <summary>
        /// Occurs when text markup link from TitleText markup is clicked. Markup links can be created using "a" tag, for example:
        /// <a name="MyLink">Markup link</a>
        /// </summary>
        [Description("Occurs when text markup link from TitleText markup is clicked.")]
        public event MarkupLinkClickEventHandler TitleTextMarkupLinkClick;
        #endregion

        #region Internal Implementation
        private TextMarkup.BodyElement _TitleTextMarkup = null;
        /// <summary>
        /// Gets or sets the rich text displayed on Ribbon Title instead of the Form.Text property. This property supports text-markup.
        /// You can use <font color="SysCaptionTextExtra"> markup to instruct the markup renderer to use Office 2007 system caption extra text color which
        /// changes depending on the currently selected color table. Note that when using this property you should manage also the Form.Text property since
        /// that is the text that will be displayed in Windows task-bar and elsewhere where system Form.Text property is used.
        /// You can also use the hyperlinks as part of the text markup and handle the TitleTextMarkupLinkClick event to be notified when they are clicked.
        /// </summary>
        [Browsable(true), DefaultValue(""), Editor("DevComponents.DotNetBar.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)), EditorBrowsable(EditorBrowsableState.Always), Category("Appearance"), Description("Indicates text displayed on Ribbon Title instead of the Form.Text property.")]
        public string TitleText
        {
            get { return _TitleText; }
            set
            {
                if (value == null) value = "";
                _TitleText = value;
                _TitleTextMarkup = null;

                if (!TextMarkup.MarkupParser.IsMarkup(ref _TitleText))
                    return;

                _TitleTextMarkup = TextMarkup.MarkupParser.Parse(_TitleText);

                if (_TitleTextMarkup != null)
                    _TitleTextMarkup.HyperLinkClick += new EventHandler(InternalTitleTextMarkupLinkClick);
                TitleTextMarkupLastArrangeBounds = Rectangle.Empty;
                this.Invalidate();
            }
        }

        /// <summary>
        /// Occurs when text markup link is clicked.
        /// </summary>
        private void InternalTitleTextMarkupLinkClick(object sender, EventArgs e)
        {
            TextMarkup.HyperLink link = sender as TextMarkup.HyperLink;
            if (link != null)
            {
                if (TitleTextMarkupLinkClick != null)
                    TitleTextMarkupLinkClick(this, new MarkupLinkClickEventArgs(link.Name, link.HRef));
            }
        }

        /// <summary>
        /// Gets reference to parsed markup body element if text was markup otherwise returns null.
        /// </summary>
        internal TextMarkup.BodyElement TitleTextMarkupBody
        {
            get { return _TitleTextMarkup; }
        }

        internal Rectangle TitleTextMarkupLastArrangeBounds = Rectangle.Empty;
        /// <summary>
        /// Gets or sets whether KeyTips functionality is enabled. Default value is true.
        /// </summary>
        [DefaultValue(true), Browsable(true), Category("Behavior"), Description("Indicates whether KeyTips functionality is enabled.")]
        public bool KeyTipsEnabled
        {
            get { return _KeyTipsEnabled; }
            set { _KeyTipsEnabled = value; }
        }

        /// <summary>
        /// Gets or sets whether control can be customized and items added by end-user using context menu to the quick access toolbar.
        /// Caption of the control must be visible for customization to be enabled. Default value is true.
        /// </summary>
        [DefaultValue(true), Browsable(true), Category("Customization"), Description("Indicates whether control can be customized. Caption must be visible for customization to be fully enabled.")]
        public bool CanCustomize
        {
            get { return _CanCustomize; }
            set { _CanCustomize = value; }
        }

        /// <summary>
        /// Gets or sets the explicit height of the caption provided by control. Caption height when set is composed of the TabGroupHeight and
        /// the value specified here. Default value is 0 which means that system default caption size is used.
        /// </summary>
        [Browsable(true), DefaultValue(0), Category("Appearance"), Description("Indicates explicit height of the caption provided by control")]
        public int CaptionHeight
        {
            get { return _CaptionHeight; }
            set
            {
                _CaptionHeight = value;
                _StripContainer.NeedRecalcSize = true;
            }
        }

        internal bool HasVisibleTabs
        {
            get
            {
                foreach (BaseItem item in this.Items)
                {
                    if (item.Visible) return true;
                }
                return false;
            }
        }

        internal Rectangle CaptionBounds
        {
            get { return _CaptionBounds; }
            set { _CaptionBounds = value; }
        }
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle QuickToolbarBounds
        {
            get { return _QuickToolbarBounds; }
            set { _QuickToolbarBounds = value; }
        }

        internal Rectangle SystemCaptionItemBounds
        {
            get { return _SystemCaptionItemBounds; }
            set { _SystemCaptionItemBounds = value; }
        }

        internal SystemCaptionItem SystemCaptionItem
        {
            get { return _StripContainer.SystemCaptionItem; }
        }

        /// <summary>
        /// Gets or sets whether custom caption line provided by the control is visible. Default value is false.
        /// This property should be set to true when control is used on Office2007RibbonForm.
        /// </summary>
        [Browsable(true), DefaultValue(false), Category("Appearance"), Description("Indicates whether custom caption line provided by the control is visible.")]
        public bool CaptionVisible
        {
            get { return _CaptionVisible; }
            set
            {
                _CaptionVisible = value;
                OnCaptionVisibleChanged();
            }
        }

        /// <summary>
        /// Gets or sets the font for the form caption text when CaptionVisible=true. Default value is NULL which means that system font is used.
        /// </summary>
        [Browsable(true), DefaultValue(null), Category("Appearance"), Description("")]
        public Font CaptionFont
        {
            get { return _CaptionFont; }
            set
            {
                _CaptionFont = value;
                _StripContainer.NeedRecalcSize = true;
                this.Invalidate();
            }
        }

        private void OnCaptionVisibleChanged()
        {
            _StripContainer.NeedRecalcSize = true;
            this.RecalcLayout();
        }

        internal eDotNetBarStyle EffectiveStyle
        {
            get
            {
                return _StripContainer.EffectiveStyle;
            }
        }
        /// <summary>
        /// Gets/Sets the visual style of the control.
        /// </summary>
        [Browsable(true), DevCoBrowsable(true), Category("Appearance"), Description("Specifies the visual style of the control."), DefaultValue(eDotNetBarStyle.Metro)]
        public eDotNetBarStyle Style
        {
            get
            {
                return _StripContainer.Style;
            }
            set
            {
                this.ColorScheme.Style = value;
                _StripContainer.Style = value;
                this.Invalidate();
                this.RecalcLayout();
            }
        }

        /// <summary>
        /// Returns collection of items on a bar.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
        public SubItemsCollection Items
        {
            get
            {
                return _StripContainer.RibbonStripContainer.SubItems;
            }
        }

        /// <summary>
        /// Returns currently selected MetroTabItem. MetroTabItems are selected using the Checked property. Only a single
        /// MetroTabItem can be Checked at any given time.
        /// </summary>
        [Browsable(false)]
        public MetroTabItem SelectedTab
        {
            get
            {
                foreach (BaseItem item in this.Items)
                {
                    if (item is MetroTabItem && ((MetroTabItem)item).Checked)
                        return (MetroTabItem)item;
                }
                return null;
            }
        }

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == (int)WinApi.WindowsMessages.WM_NCHITTEST)
            {
                // Get position being tested...
                int x = WinApi.LOWORD(m.LParam);
                int y = WinApi.HIWORD(m.LParam);
                Point p = PointToClient(new Point(x, y));
                if (IsGlassEnabled && this.CaptionVisible)
                {
                    Rectangle r = new Rectangle(this.Width - BarFunctions.CaptionButtonSize.Width * 3, 0, BarFunctions.CaptionButtonSize.Width * 3, BarFunctions.CaptionButtonSize.Height + 6);
                    if (r.Contains(p))
                    {
                        m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
                        return;
                    }

                    r = new Rectangle(0, 0, this.Width, 4);
                    if (r.Contains(p))
                    {
                        m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
                        return;
                    }

                    if (_CaptionBounds.Contains(p))
                    {
                        m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
                        return;
                    }
                }
                else if (this.CaptionVisible && !this.IsMaximized)
                {
                    Rectangle r = new Rectangle(0, 0, this.Width, 4);
                    if (r.Contains(p))
                    {
                        m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
                        return;
                    }
                }
                if (BarFunctions.IsWindows7 && this.IsMaximized)
                {
                    if(this.CaptionBounds.Contains(p))
                    {
                        m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
                        return;
                    }
                }
            }

            base.WndProc(ref m);
        }

        internal bool IsMaximized
        {
            get
            {
                Form f = this.FindForm();
                return (f != null && f.WindowState == FormWindowState.Maximized);
            }
        }

        /// <summary>
        /// Returns the color scheme used by control. Color scheme for Office2007 style will be retrived from the current renderer instead of
        /// local color scheme referenced by ColorScheme property.
        /// </summary>
        /// <returns>An instance of ColorScheme object.</returns>
        protected override ColorScheme GetColorScheme()
        {
            BaseRenderer r = GetRenderer();
            if (r is Office2007Renderer)
                return ((Office2007Renderer)r).ColorTable.LegacyColors;
            return base.GetColorScheme();
        }

        protected override void PaintControlBackground(ItemPaintArgs pa)
        {
            base.PaintControlBackground(pa);

            _QuickToolbarBounds = Rectangle.Empty;
            _CaptionBounds = Rectangle.Empty;
            _SystemCaptionItemBounds = Rectangle.Empty;

            MetroRender.Paint(this, pa);
            //DevComponents.DotNetBar.Rendering.BaseRenderer renderer = GetRenderer();
            //if (renderer != null && this.Parent is MetroTab)
            //{
            //    renderer.DrawMetroTabBackground(new MetroTabRendererEventArgs(pa.Graphics, this.Parent as MetroTab, pa.GlassEnabled));

            //    if (_CaptionVisible)
            //        renderer.DrawQuickAccessToolbarBackground(new MetroTabRendererEventArgs(pa.Graphics, this.Parent as MetroTab, pa.GlassEnabled));
            //}

            //// Paint form caption text
            //if (renderer != null && _CaptionVisible)
            //{
            //    MetroTabRendererEventArgs rer = new MetroTabRendererEventArgs(pa.Graphics, this.Parent as MetroTab, pa.GlassEnabled);
            //    rer.ItemPaintArgs = pa;
            //    renderer.DrawRibbonFormCaptionText(rer);
            //}

#if TRIAL
            if (NativeFunctions.ColorExpAlt())
				{
					pa.Graphics.Clear(Color.White);
					TextDrawing.DrawString(pa.Graphics, "Your DotNetBar trial has expired :-(", this.Font, Color.FromArgb(128, Color.Black), this.ClientRectangle, eTextFormat.HorizontalCenter | eTextFormat.VerticalCenter);
				}
                //else
                //{
                //    TextDrawing.DrawString(pa.Graphics, "Trial Version", this.Font, Color.FromArgb(128, Color.Black), new Rectangle(0, 0, this.Width - 12, this.Height-4), eTextFormat.Right | eTextFormat.Bottom);
                //}
#endif
        }

        protected override ElementStyle GetBackgroundStyle()
        {
            if (this.BackgroundStyle.Custom)
                return base.GetBackgroundStyle();
            return _DefaultBackgroundStyle;
        }

        internal void InitDefaultStyles()
        {
            _DefaultBackgroundStyle = MetroRender.GetColorTable().MetroTab.TabStrip.BackgroundStyle;
        }

        internal ElementStyle InternalGetBackgroundStyle()
        {
            return this.GetBackgroundStyle();
        }

        internal Rectangle GetItemContainerBounds()
        {
            Rectangle r = base.GetItemContainerRectangle();
            if (_CaptionVisible)
            {
                r.Y += GetAbsoluteCaptionHeight();
            }
            return r;
        }

        internal Rectangle GetCaptionContainerBounds()
        {
            Rectangle baseRect = base.GetItemContainerRectangle();
            if (this.IsGlassEnabled)
                baseRect.Y += 3;
            return new Rectangle(baseRect.X, baseRect.Y, baseRect.Width, GetAbsoluteCaptionHeight());
        }
        /// <summary>
        /// Returns effective caption height.
        /// </summary>
        /// <returns>Caption height.</returns>
        public int GetCaptionHeight()
        {
            if (_CaptionHeight == 0)
            {
                if (StyleManager.Style == eStyle.OfficeMobile2014 || StyleManager.Style == eStyle.Office2016)
                    return Dpi.Height32;
                else
                    return Dpi.Height25;
            }
            else
            {
                return Dpi.Height(_CaptionHeight);
            }
        }

        internal int GetAbsoluteCaptionHeight()
        {
            return GetCaptionHeight();
        }

        internal int GetTotalCaptionHeight()
        {
            return GetCaptionHeight();
        }

        internal override bool IsGlassEnabled
        {
            get
            {
                return false;
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            if (_StripContainer.NeedRecalcSize) this.RecalcSize();
            InitDefaultStyles();
            base.OnPaint(e);
        }

        protected override void RecalcSize()
        {
            _CaptionBounds = Rectangle.Empty;
            _SystemCaptionItemBounds = Rectangle.Empty;
            _QuickToolbarBounds = Rectangle.Empty;
            InitDefaultStyles();
            base.RecalcSize();
        }

        /// <summary>
        /// Returns automatically calculated height of the control given current content.
        /// </summary>
        /// <returns>Height in pixels.</returns>
        public override int GetAutoSizeHeight()
        {
            int i = base.GetAutoSizeHeight();
            return i;
        }

        protected override bool OnMouseWheel(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            Rectangle r = this.DisplayRectangle;
            r.Location = this.PointToScreen(r.Location);

            MetroShell rc = this.Parent as MetroShell;

            if (this.Parent is MetroShell)
            {
                r = this.Parent.DisplayRectangle;
                r.Location = this.Parent.PointToScreen(r.Location);
                if (rc.SelectedTab != null && rc.SelectedTab.Panel is IKeyTipsControl && ((IKeyTipsControl)rc.SelectedTab.Panel).ShowKeyTips)
                    return false;
            }

            if (rc != null && !rc.MouseWheelTabScrollEnabled) return false;

            Point mousePos = Control.MousePosition;

            bool parentActive = true;
            Form parentForm = this.FindForm();
            if (parentForm != null && !BarFunctions.IsFormActive(parentForm))
                parentActive = false;

            if (parentActive && r.Contains(mousePos) && !this.ShowKeyTips && this.Items.Count > 0)
            {
                IntPtr handle = NativeFunctions.WindowFromPoint(new NativeFunctions.POINT(mousePos));
                Control c = Control.FromChildHandle(handle);
                if (c == null)
                    c = Control.FromHandle(handle);
                if (c is MetroTabStrip || c is MetroShell || c is MetroTabPanel)
                {
                    MetroTabItem selectedTab = this.SelectedTab;
                    int start = 0;
                    int end = this.Items.Count - 1;

                    int direction = 1;
                    if ((wParam.ToInt64() & 0x80000000) > 0)
                    {
                        direction = -1;
                        end = 0;
                    }
                    if (selectedTab != null)
                    {
                        start = this.Items.IndexOf(selectedTab) + direction;
                        if (direction < 0 && start < 0) return false;

                        if (start == this.Items.Count)
                            start = 0;
                        else if (start < 0)
                            start = this.Items.Count - 1;
                    }

                    int index = start - direction;
                    do
                    {
                        index += direction;
                        if (index < 0 || index > this.Items.Count - 1) break;

                        if (this.Items[index] is MetroTabItem && this.Items[index].Visible)
                        {
                            ((MetroTabItem)this.Items[index]).Checked = true;
                            return true;
                        }
                    } while (index != end);
                }
            }

            return false;
        }

        /// <summary>
        /// Returns the collection of items with the specified name.
        /// </summary>
        /// <param name="ItemName">Item name to look for.</param>
        /// <returns></returns>
        public override ArrayList GetItems(string ItemName)
        {
            ArrayList list = new ArrayList(15);
            BarFunctions.GetSubItemsByName(GetBaseItemContainer(), ItemName, list);

            MetroShell rc = this.GetMetroTab();

            if (rc != null && rc.GlobalContextMenuBar != null)
                BarFunctions.GetSubItemsByName(rc.GlobalContextMenuBar.ItemsContainer, 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>
        public override ArrayList GetItems(string ItemName, Type itemType)
        {
            ArrayList list = new ArrayList(15);
            BarFunctions.GetSubItemsByNameAndType(GetBaseItemContainer(), ItemName, list, itemType);

            MetroShell rc = this.GetMetroTab();
            if (rc != null && rc.GlobalContextMenuBar != null)
                BarFunctions.GetSubItemsByNameAndType(rc.GlobalContextMenuBar.ItemsContainer, 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>
        public override ArrayList GetItems(string ItemName, Type itemType, bool useGlobalName)
        {
            ArrayList list = new ArrayList(15);
            BarFunctions.GetSubItemsByNameAndType(GetBaseItemContainer(), ItemName, list, itemType, useGlobalName);

            MetroShell rc = this.GetMetroTab();

            if (rc != null && rc.GlobalContextMenuBar != null)
                BarFunctions.GetSubItemsByNameAndType(rc.GlobalContextMenuBar.ItemsContainer, 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>
        public override BaseItem GetItem(string ItemName)
        {
            BaseItem item = BarFunctions.GetSubItemByName(GetBaseItemContainer(), ItemName);
            if (item != null)
                return item;

            MetroShell rc = this.GetMetroTab();
            if (rc != null && rc.GlobalContextMenuBar != null)
                return BarFunctions.GetSubItemByName(rc.GlobalContextMenuBar.ItemsContainer, ItemName);

            return null;
        }
        #endregion

        #region KeyTips Support
        private bool _AltFocus = false;
        private IKeyTipsControl _AltFocusedControl = null;

        /// <summary>
        /// Called when ShowKeyTips on RibbonBar contained by this Ribbon is set to true
        /// </summary>
        internal void OnRibbonBarShowKeyTips(RibbonBar bar)
        {
            if (!_AltFocus)
            {
                _AltFocus = true;
            }

            if (_AltFocusedControl != bar.Parent && bar.Parent is RibbonPanel)
            {
                if (_AltFocusedControl != null)
                    _AltFocusedControl.ShowKeyTips = false;
                _AltFocusedControl = bar.Parent as IKeyTipsControl;
                if (_AltFocusedControl != null)
                    _AltFocusedControl.ShowKeyTips = true;
            }
        }

        protected override void OnShowKeyTipsChanged()
        {
            MetroShell rc = this.GetMetroTab();
            base.OnShowKeyTipsChanged();

            if (this.ShowKeyTips && !_AltFocus)
                GiveKeyTipsAltFocus();
        }

        internal void BackstageTabClosed(SuperTabControl tabControl)
        {
            if (_AltFocusedControl == tabControl || _AltFocusedControl == tabControl.TabStrip)
                _AltFocusedControl = null;
        }

        protected override bool OnKeyDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            if (_AltFocus)
            {
                if (HasRegisteredPopups)
                {
                    bool ret = base.OnKeyDown(hWnd, wParam, lParam);
                    if (!HasRegisteredPopups) ReleaseAltFocus();
                }
                Keys key = (Keys)NativeFunctions.MapVirtualKey((uint)wParam, 2);
                if (key == Keys.None)
                {
                    int wParamInt = WinApi.ToInt(wParam);
                    key = (Keys)wParamInt;
                }

                if (key == Keys.Escape)
                {
                    bool reShowKeyTips = false;
                    if (!this.ShowKeyTips && _AltFocusedControl != null)
                    {
                        if (_AltFocusedControl is RibbonPanel)
                            reShowKeyTips = true;
                    }

                    ReleaseAltFocus();

                    if (reShowKeyTips)
                    {
                        GiveKeyTipsAltFocus();
                    }

                    return base.OnKeyDown(hWnd, wParam, lParam);
                }

                char accessKey = CharFromInt((int)key);
                if (accessKey == char.MinValue)
                {
                    ReleaseAltFocus();
                    return true;
                }
                else if (key == Keys.Space || key == Keys.Down || key == Keys.Right || key == Keys.Tab)
                {
                    ReleaseAltFocus();
                    return false;
                }

                if (this.ProcessMnemonic(accessKey))
                    return true;

                return true;
            }

            return base.OnKeyDown(hWnd, wParam, lParam);
        }

        private char CharFromInt(int key)
        {
            char[] ch = new char[1];
            byte[] by = new byte[1];
            try
            {
                by[0] = System.Convert.ToByte(key);
                System.Text.Encoding.Default.GetDecoder().GetChars(by, 0, 1, ch, 0);
            }
            catch (Exception)
            {
                return char.MinValue;
            }

            return ch[0];
        }

        protected override bool OnSysKeyUp(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            int wParamInt = WinApi.ToInt(wParam);
            if (wParamInt == 18 || wParamInt == 121)
            {
                bool callBase = true;
                if (_AltFocus)
                {
                    if (wParamInt == 18 || wParamInt == 121)
                        callBase = false;
                    ReleaseAltFocus();
                }
                else
                {
                    Form f = this.FindForm();
                    if (f == Form.ActiveForm)
                    {
                        callBase = false;
                        GiveKeyTipsAltFocus();
                    }
                }
                if (!callBase)
                    return true;
            }
            return base.OnSysKeyUp(hWnd, wParam, lParam);
        }

        private void GiveKeyTipsAltFocus()
        {
            if (!_KeyTipsEnabled) return;

            _AltFocus = true;
            this.ShowKeyTips = true;
            SetupActiveWindowTimer();
        }

        private void ReleaseAltFocus()
        {
            if (_AltFocus)
            {
                ReleaseActiveWindowTimer();
                if (!this.ShowKeyTips && _AltFocusedControl != null)
                {
                    _AltFocusedControl.ShowKeyTips = false;
                    _AltFocusedControl = null;
                }
                this.ShowKeyTips = false;
            }

            _AltFocus = false;
        }

        /// <summary>
        /// Gets whether Ribbon is in key-tips mode including its child controls.
        /// </summary>
        [Browsable(false)]
        public bool IsInKeyTipsMode
        {
            get
            {
                return _AltFocus | this.ShowKeyTips;
            }
        }

        /// <summary>
        /// Forces the control to exit Ribbon Key-Tips mode.
        /// </summary>
        public void ExitKeyTipsMode()
        {
            ReleaseAltFocus();
        }

        internal void OnChildItemClick(BaseItem item)
        {
            if (this.ShowKeyTips || _AltFocusedControl != null && _AltFocusedControl.ShowKeyTips)
            {
                this.ShowKeyTips = false;
                ReleaseAltFocus();
            }
        }

        protected override bool OnSysMouseDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
        {
            if (this.ShowKeyTips || _AltFocusedControl != null && _AltFocusedControl.ShowKeyTips)
            {
                this.ShowKeyTips = false;
                ReleaseAltFocus();
            }

            return base.OnSysMouseDown(hWnd, wParam, lParam);
        }

        protected override bool ProcessMnemonic(char charCode)
        {
            if (_AltFocusedControl != null)
            {
                if (_AltFocusedControl.ProcessMnemonicEx(charCode))
                {
                    ReleaseAltFocus();
                    return true;
                }
                return false;
            }
            if (!_AltFocus && (Control.ModifierKeys & Keys.Alt) != Keys.Alt)
                return false;
            return base.ProcessMnemonic(charCode);
        }

        public override bool ProcessMnemonicEx(char charCode)
        {
            // If different ribbon tab item is selected we should not exit the Alt mode...
            BaseItem item = null;

            if (_CaptionVisible)
            {
                item = GetItemForMnemonic(_StripContainer.CaptionContainer, charCode, false, true);
                if (item != null)
                {
                    if (ProcessItemMnemonicKey(item))
                    {
                        ReleaseAltFocus();
                        return true;
                    }
                }
            }

            MetroShell rc = this.GetMetroTab();

            if (item == null)
            {
                item = GetItemForMnemonic(this.GetBaseItemContainer(), charCode, true, true);
            }

            if (item is MetroTabItem && item.Visible)
            {
                if (!_AltFocus)
                {
                    GiveKeyTipsAltFocus();
                }
                this.ShowKeyTips = false;
                if (item != this.SelectedTab)
                {
                    // Switch the tab
                    item.RaiseClick();
                    //this.ShowKeyTips = true;
                }
                if (this.SelectedTab != null && _KeyTipsEnabled)
                {
                    if (_AltFocusedControl != null)
                        _AltFocusedControl.ShowKeyTips = false;
                    _AltFocusedControl = this.SelectedTab.Panel;
                    if (_AltFocusedControl != null)
                        _AltFocusedControl.ShowKeyTips = true;
                }

                // Keep the Alt focus
                return true;
            }
            else if (item != null && ProcessItemMnemonicKey(item))
            {
                this.ShowKeyTips = false;
                if (item is MetroAppButton)
                {
                    MetroAppButton appButton = (MetroAppButton)item;
                    if (appButton.BackstageTab != null)
                    {
                        if (_AltFocusedControl != null)
                            _AltFocusedControl.ShowKeyTips = false;
                        _AltFocusedControl = appButton.BackstageTab.TabStrip;
                        if (!_AltFocusedControl.ShowKeyTips)
                            _AltFocusedControl.ShowKeyTips = true;
                    }

                }
                return true;
            }

            //if (base.ProcessMnemonicEx(charCode))
            //{
            //    ReleaseAltFocus();
            //    return true;
            //}

            if (_AltFocus && this.SelectedTab != null && this.SelectedTab.Panel != null)
            {
                Control panel = this.SelectedTab.Panel;
                foreach (Control c in panel.Controls)
                {
                    if (c is RibbonBar && c.Visible)
                    {
                        if (IsMnemonic(charCode, c.Text))
                        {
                            // Select RibbonBar for Alt+ Key access
                            this.ShowKeyTips = false;
                            ((RibbonBar)c).ShowKeyTips = true;
                            if (_AltFocusedControl != null)
                                _AltFocusedControl.ShowKeyTips = false;
                            _AltFocusedControl = (IKeyTipsControl)c;
                            return true;
                        }
                    }
                }
            }

            return false;
        }

        protected override void OnActiveWindowChanged()
        {
            ReleaseAltFocus();
            base.OnActiveWindowChanged();
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            return base.ProcessCmdKey(ref msg, keyData);
        }

        protected override bool ProcessDialogKey(Keys keyData)
        {
            return base.ProcessDialogKey(keyData);
        }
        #endregion

        #region Caption Container Support
        private bool _ShowIcon = true;
        /// <summary>
        /// Indicates whether Form.Icon is shown in top-left corner.
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates whether Form.Icon is shown in top-left corner.")]
        public bool ShowIcon
        {
            get
            {
                return _ShowIcon;
            }
            set
            {
                if (_ShowIcon != value) 
                {
                    _ShowIcon = value;
                    _StripContainer.NeedRecalcSize = true;
                    this.RecalcLayout();
                }
            }
        }

        /// <summary>
        /// Called when item on popup container is right-clicked.
        /// </summary>
        /// <param name="item">Instance of the item that is right-clicked.</param>
        protected override void OnPopupItemRightClick(BaseItem item)
        {
            MetroShell rc = this.GetMetroTab();
            if (rc != null)
                rc.ShowCustomizeContextMenu(item, false);
        }
        //private MetroTab GetMetroTab()
        //{
        //    Control parent = this.Parent;
        //    while (parent != null && !(parent is MetroTab))
        //        parent = parent.Parent;
        //    if (parent is MetroTab)
        //        return parent as MetroTab;
        //    return null;
        //}
        protected override void OnMouseLeave(EventArgs e)
        {
            if (_TitleTextMarkup != null)
                _TitleTextMarkup.MouseLeave(this);
            base.OnMouseLeave(e);
        }

        internal bool MouseDownOnCaption
        {
            get
            {
                return _MouseDownOnCaption;
            }
        }

        private MetroShell GetMetroTab()
        {
            return this.Parent as MetroShell;
        }

        internal void ShowSystemMenu(Point p)
        {
            Form form = this.FindForm();
            if (form is MetroAppForm)
                ((MetroAppForm)form).ShowSystemWindowMenu(p);
            else
            {
                const int TPM_RETURNCMD = 0x0100;
                byte[] bx = BitConverter.GetBytes(p.X);
                byte[] by = BitConverter.GetBytes(p.Y);
                byte[] blp = new byte[] { bx[0], bx[1], by[0], by[1] };
                int lParam = BitConverter.ToInt32(blp, 0);
                this.Capture = false;
                NativeFunctions.SendMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.TrackPopupMenu(
                    NativeFunctions.GetSystemMenu(form.Handle, false), TPM_RETURNCMD, p.X, p.Y, 0, form.Handle, IntPtr.Zero), lParam);
            }
        }

        private bool _MouseDownOnCaption = false;
        private Point _MouseDownPoint = Point.Empty;
        protected override void OnMouseDown(MouseEventArgs e)
        {
            _MouseDownOnCaption = false;
            _MouseDownPoint = e.Location;
            if (_CaptionVisible)
            {
                _MouseDownOnCaption = HitTestCaption(new Point(e.X, e.Y));
                if (e.Button == MouseButtons.Right && _MouseDownOnCaption)
                {
                    ShowSystemMenu(Control.MousePosition);
                    return;
                }

                if (_TitleTextMarkup != null)
                    _TitleTextMarkup.MouseDown(this, e);

                e = TranslateMouseEventArgs(e);
            }

            if (e.Button == MouseButtons.Right && this.QuickToolbarBounds.Contains(e.X, e.Y))
            {
                MetroShell mt = this.GetMetroTab();
                if (mt != null)
                    mt.OnTabStripRightClick(this, e.X, e.Y);
            }

            base.OnMouseDown(e);
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (_CaptionVisible)
            {
                if (_TitleTextMarkup != null)
                    _TitleTextMarkup.MouseUp(this, e);

                e = TranslateMouseEventArgs(e);
            }
            _MouseDownOnCaption = false;
            base.OnMouseUp(e);
        }

        internal BaseItem GetApplicationButton()
        {
            if (!this.CaptionVisible)
                return null;
            BaseItem cont = this.CaptionContainerItem;

            if (this.EffectiveStyle == eDotNetBarStyle.Office2010 && this.Items.Count > 0 && this.Items[0] is MetroAppButton)
                return this.Items[0];

            if (cont.SubItems.Count > 0 && cont.SubItems[0] is MetroAppButton)
                return cont.SubItems[0];

            if (cont.SubItems.Count > 0 && cont.SubItems[0] is ButtonItem && ((ButtonItem)cont.SubItems[0]).HotTrackingStyle == eHotTrackingStyle.Image)
                return cont.SubItems[0];

            return null;
        }
        /// <summary>
        /// Starts moving of the parent form action which happens when user attempts to drag the form caption.
        /// </summary>
        public void StartFormMove()
        {
            Form form = this.FindForm();
            if (form != null && form.WindowState == FormWindowState.Normal)
            {
                PopupItem popup = GetApplicationButton() as PopupItem;
                if (popup != null && popup.Expanded) popup.Expanded = false;

                const int HTCAPTION = 2;
                Point p = Control.MousePosition;
                byte[] bx = BitConverter.GetBytes(p.X);
                byte[] by = BitConverter.GetBytes(p.Y);
                byte[] blp = new byte[] { bx[0], bx[1], by[0], by[1] };
                int lParam = BitConverter.ToInt32(blp, 0);
                this.Capture = false;
                NativeFunctions.SendMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MOVE + HTCAPTION, lParam);
                _MouseDownOnCaption = false;
            }
        }
        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (_CaptionVisible)
            {
                if (e.Button == MouseButtons.Left && (_MouseDownOnCaption && HitTestCaption(new Point(e.X, e.Y)) || HitTest(_MouseDownPoint.X, _MouseDownPoint.Y)==null))
                {
                    Form form = this.FindForm();
                    if (form != null && form.WindowState == FormWindowState.Normal)
                    {
                        StartFormMove();
                        return;
                    }
                }
                if (_TitleTextMarkup != null)
                    _TitleTextMarkup.MouseMove(this, e);
                e = TranslateMouseEventArgs(e);
            }
            base.OnMouseMove(e);
        }

        protected override void InternalOnClick(MouseButtons mb, Point mousePos)
        {
            if (_CaptionVisible)
            {
                MouseEventArgs e = new MouseEventArgs(mb, 0, mousePos.X, mousePos.Y, 0);
                e = TranslateMouseEventArgs(e);
                mousePos = new Point(e.X, e.Y);
            }

            base.InternalOnClick(mb, mousePos);
        }

        private MouseEventArgs TranslateMouseEventArgs(MouseEventArgs e)
        {
            if (e.Y <= 6)
            {
                Form form = this.FindForm();
                if (form != null && form.WindowState == FormWindowState.Maximized && form is RibbonForm)
                {
                    if (e.X <= 4)
                    {
                        BaseItem sb = GetApplicationButton();
                        if (sb != null)
                        {
                            e = new MouseEventArgs(e.Button, e.Clicks, sb.LeftInternal + 1, sb.TopInternal + 1, e.Delta);
                        }
                    }
                    else if (e.X >= this.Width - 6)
                        e = new MouseEventArgs(e.Button, e.Clicks, this.SystemCaptionItem.DisplayRectangle.Right - 4, this.SystemCaptionItem.DisplayRectangle.Top + 4, e.Delta);
                    else
                        e = new MouseEventArgs(e.Button, e.Clicks, e.X, this.CaptionContainerItem.TopInternal + 5, e.Delta);
                }
            }
            return e;
        }

        protected override void OnClick(EventArgs e)
        {
            if (_CaptionVisible)
            {
                if (_TitleTextMarkup != null)
                    _TitleTextMarkup.Click(this);
            }
            base.OnClick(e);
        }

        protected override void OnDoubleClick(EventArgs e)
        {
            if (_CaptionVisible)
            {
                // Check whether double click is on caption so window can be maximized/restored
                Point p = this.PointToClient(Control.MousePosition);
                if (HitTestCaption(p))
                {
                    Form form = this.FindForm();
                    if (form != null && form.MaximizeBox && (form.FormBorderStyle == FormBorderStyle.Sizable || form.FormBorderStyle == FormBorderStyle.SizableToolWindow))
                    {
                        if (form.WindowState == FormWindowState.Normal)
                        {
                            NativeFunctions.PostMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MAXIMIZE, 0);
                        }
                        else if (form.WindowState == FormWindowState.Maximized)
                        {
                            NativeFunctions.PostMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_RESTORE, 0);
                        }
                    }
                }
            }
            base.OnDoubleClick(e);
        }

        /// <summary>
        /// Returns true if point is inside the caption area.
        /// </summary>
        /// <param name="p">Client point coordinates.</param>
        /// <returns>True if point is inside of caption area otherwise false.</returns>
        protected bool HitTestCaption(Point p)
        {
            return _CaptionBounds.Contains(p);
        }

        private void SystemCaptionClick(object sender, EventArgs e)
        {
            SystemCaptionItem sci = sender as SystemCaptionItem;
            Form frm = this.FindForm();

            if (frm == null)
                return;

            if (sci.LastButtonClick == sci.MouseDownButton)
            {
                if (sci.LastButtonClick == SystemButton.Minimize)
                {
                    NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MINIMIZE, 0);
                }
                else if (sci.LastButtonClick == SystemButton.Maximize)
                {
                    NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MAXIMIZE, 0);
                }
                else if (sci.LastButtonClick == SystemButton.Restore)
                {
                    NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_RESTORE, 0);
                }
                else if (sci.LastButtonClick == SystemButton.Close)
                {
                    NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_CLOSE, 0);
                }
                else if (sci.LastButtonClick == SystemButton.Help)
                {
                    NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_CONTEXTHELP, 0);
                }
            }
        }

        internal void CloseParentForm()
        {
            Form frm = this.FindForm();

            if (frm == null)
                return;
            
            NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_CLOSE, 0);
        }


        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            if (!_CaptionVisible)
                return;

            Form frm = this.FindForm();
            if (frm == null)
                return;

            if (frm.WindowState == FormWindowState.Maximized || frm.WindowState == FormWindowState.Minimized)
                _StripContainer.SystemCaptionItem.RestoreEnabled = true;
            else
                _StripContainer.SystemCaptionItem.RestoreEnabled = false;
        }

        /// <summary>
        /// Returns collection of items on a bar.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
        public SubItemsCollection QuickToolbarItems
        {
            get { return _StripContainer.CaptionContainer.SubItems; }
        }

        /// <summary>
        /// Gets the reference to the internal container item for the items displayed in control caption.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public GenericItemContainer CaptionContainerItem
        {
            get { return _StripContainer.CaptionContainer; }
        }

        /// <summary>
        /// Gets the reference to the internal container for the ribbon tabs and other items.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public SimpleItemContainer StripContainerItem
        {
            get { return _StripContainer.RibbonStripContainer; }
        }

        internal MetroStripContainerItem MetroStripContainer
        {
            get
            {
                return _StripContainer;
            }
        }

        protected override void PaintKeyTips(Graphics g)
        {
            if (!this.ShowKeyTips)
                return;

            KeyTipsRendererEventArgs e = new KeyTipsRendererEventArgs(g, Rectangle.Empty, "", GetKeyTipFont(), null);

            DevComponents.DotNetBar.Rendering.BaseRenderer renderer = GetRenderer();
            PaintContainerKeyTips(_StripContainer.RibbonStripContainer, renderer, e);
            if (_CaptionVisible)
                PaintContainerKeyTips(_StripContainer.CaptionContainer, renderer, e);
        }

        protected override Rectangle GetKeyTipRectangle(Graphics g, BaseItem item, Font font, string keyTip)
        {
            Rectangle r = base.GetKeyTipRectangle(g, item, font, keyTip);
            if (this.QuickToolbarItems.Contains(item))
                r.Y += 4;
            return r;
        }
        #endregion

        #region Mdi Child System Item
        internal void ClearMDIChildSystemItems(bool bRecalcLayout)
        {
            if (_StripContainer.RibbonStripContainer == null)
                return;
            bool recalc = false;
            try
            {
                if (this.Items.Contains("dotnetbarsysiconitem"))
                {
                    this.Items.Remove("dotnetbarsysiconitem");
                    recalc = true;
                }
                if (this.Items.Contains("dotnetbarsysmenuitem"))
                {
                    this.Items.Remove("dotnetbarsysmenuitem");
                    recalc = true;
                }
                if (bRecalcLayout && recalc)
                    this.RecalcLayout();
            }
            catch (Exception)
            {
            }
        }

        internal void ShowMDIChildSystemItems(System.Windows.Forms.Form objMdiChild, bool bRecalcLayout)
        {
            ClearMDIChildSystemItems(bRecalcLayout);

            if (objMdiChild == null)
                return;

            MDISystemItem mdi = new MDISystemItem("dotnetbarsysmenuitem");
            if (!objMdiChild.ControlBox)
                mdi.CloseEnabled = false;
            if (!objMdiChild.MinimizeBox)
                mdi.MinimizeEnabled = false;
            if (!objMdiChild.MaximizeBox)
            {
                mdi.RestoreEnabled = false;
            }
            mdi.ItemAlignment = eItemAlignment.Far;
            mdi.Click += new System.EventHandler(this.MDISysItemClick);

            this.Items.Add(mdi);

            if (bRecalcLayout)
                this.RecalcLayout();
        }

        private void MDISysItemClick(object sender, System.EventArgs e)
        {
            MDISystemItem mdi = sender as MDISystemItem;
            Form frm = this.FindForm();
            if (frm != null)
                frm = frm.ActiveMdiChild;
            if (frm == null)
            {
                ClearMDIChildSystemItems(true);
                return;
            }
            if (mdi.LastButtonClick == SystemButton.Minimize)
            {
                NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MINIMIZE, 0);
            }
            else if (mdi.LastButtonClick == SystemButton.Restore)
            {
                NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_RESTORE, 0);
            }
            else if (mdi.LastButtonClick == SystemButton.Close)
            {
                NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_CLOSE, 0);
            }
            else if (mdi.LastButtonClick == SystemButton.NextWindow)
            {
                NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_NEXTWINDOW, 0);
            }
        }
        #endregion

        internal void InvokeMouseDown(MouseEventArgs e)
        {
            OnMouseDown(e);
        }

        internal void InvokeMouseMove(MouseEventArgs e)
        {
            OnMouseMove(e);
        }

        internal void InvokeMouseUp(MouseEventArgs e)
        {
            OnMouseUp(e);
        }

        internal void InvokeClick(EventArgs e)
        {
            OnClick(e);
        }
    }
}