// *********************************
// Message from Original Author:
//
// 2008 Jose Menendez Poo
// Please give me credit if you use this code. It's all I ask.
// Contact me for more info: menendezpoo@gmail.com
// *********************************
//
// Original project from http://ribbon.codeplex.com/
// Continue to support and maintain by http://officeribbon.codeplex.com/


using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;

namespace System.Windows.Forms
{
    [DesignTimeVisible(false)]
    [Designer(typeof(RibbonPanelDesigner))]
    public class RibbonPanel :
        Component, IRibbonElement, IContainsSelectableRibbonItems, IContainsRibbonComponents
    {
        #region Fields
        private bool? _isopeninvisualstudiodesigner;
        private bool _enabled;
        private Image _image;
        private string _text;
        private bool _selected;
        private RibbonPanelFlowDirection _flowsTo;
        private bool _buttonMoreVisible;
        private bool _buttonMoreEnabled;
        internal Rectangle overflowBoundsBuffer;
        private bool _visible = true;

        #endregion

        #region Events
        /// <summary>
        /// Occurs when the mouse pointer enters the panel
        /// </summary>
        public event MouseEventHandler MouseEnter;

        /// <summary>
        /// Occurs when the mouse pointer leaves the panel
        /// </summary>
        public event MouseEventHandler MouseLeave;

        /// <summary>
        /// Occurs when the mouse pointer is moved inside the panel
        /// </summary>
        public event MouseEventHandler MouseMove;

        /// <summary>
        /// Occurs when the panel is redrawn
        /// </summary>
        public event PaintEventHandler Paint;

        /// <summary>
        /// Occurs when the panel is resized
        /// </summary>
        public event EventHandler Resize;

        public event EventHandler ButtonMoreClick;

        public virtual event EventHandler Click;

        public virtual event EventHandler DoubleClick;

        public virtual event MouseEventHandler MouseDown;

        public virtual event MouseEventHandler MouseUp;
        #endregion

        #region Ctor
        /// <summary>
        /// Creates a new RibbonPanel
        /// </summary>
        public RibbonPanel()
        {
            Items = new RibbonItemCollection();
            Items.SetOwnerPanel(this);
            SizeMode = RibbonElementSizeMode.None;
            _flowsTo = RibbonPanelFlowDirection.Bottom;
            _buttonMoreEnabled = true;
            _buttonMoreVisible = true;
            _enabled = true;
        }

        /// <summary>
        /// Creates a new RibbonPanel with the specified text
        /// </summary>
        /// <param name="text">Text of the panel</param>
        public RibbonPanel(string text)
            : this(text, RibbonPanelFlowDirection.Bottom)
        {

        }

        /// <summary>
        /// Creates a new RibbonPanel with the specified text and panel flow direction
        /// </summary>
        /// <param name="text">Text of the panel</param>
        /// <param name="flowsTo">Flow direction of the content items</param>
        public RibbonPanel(string text, RibbonPanelFlowDirection flowsTo)
            : this(text, flowsTo, new RibbonItem[] { })
        {
        }

        /// <summary>
        /// Creates a new RibbonPanel with the specified text and panel flow direction
        /// </summary>
        /// <param name="text">Text of the panel</param>
        /// <param name="flowsTo">Flow direction of the content items</param>
        /// <param name="items">content items</param>
        public RibbonPanel(string text, RibbonPanelFlowDirection flowsTo, IEnumerable<RibbonItem> items)
            : this()
        {
            _text = text;
            _flowsTo = flowsTo;
            Items.AddRange(items);
        }

        /// <summary>
        /// RibbonPanel is open in Visual Studio Designer
        /// </summary>
        protected bool IsOpenInVisualStudioDesigner()
        {
            if (!_isopeninvisualstudiodesigner.HasValue)
            {
                _isopeninvisualstudiodesigner = LicenseManager.UsageMode == LicenseUsageMode.Designtime ||
                                                this.DesignMode;
                if (!_isopeninvisualstudiodesigner.Value)
                {
                    try
                    {
                        using (var process = System.Diagnostics.Process.GetCurrentProcess())
                        {
                            _isopeninvisualstudiodesigner = process.ProcessName.ToLowerInvariant().Contains("devenv");
                        }
                    }
                    catch
                    {
                    }
                }
            }
            return _isopeninvisualstudiodesigner.Value;
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && RibbonDesigner.Current == null)
            {
                try
                {
                    foreach (RibbonItem ri in Items)
                        ri.Dispose();
                }
                catch (InvalidOperationException)
                {
                    if (!IsOpenInVisualStudioDesigner())
                    {
                        throw;
                    }
                }
            }

            base.Dispose(disposing);
        }

        #endregion

        #region Props

        private string _Name = string.Empty;
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public virtual string Name
        {
            get
            {
                if (Site != null)
                {
                    _Name = Site.Name;
                }
                return _Name;
            }
            set => _Name = value;
        }

        [DefaultValue(true)]
        [Category("Behavior")]
        [Description("Sets if the panel should be enabled")]
        public bool Enabled
        {
            get
            {
                if (OwnerTab != null)
                {
                    return _enabled && OwnerTab.Enabled;
                }

                return _enabled;
            }
            set
            {
                _enabled = value;
                Owner.Invalidate();

                foreach (RibbonItem item in Items)
                {
                    item.Enabled = value;
                }
            }
        }

        [DefaultValue(true)]
        [Category("Behavior")]
        [Description("Sets if the panel should be Visible")]
        public virtual bool Visible
        {
            get
            {
                if (Owner != null && !Owner.IsDesignMode() && OwnerTab != null && !OwnerTab.Visible)
                    return false;
                return _visible;
            }
            set
            {
                _visible = value;
                //this.OwnerTab.UpdatePanelsRegions();
                if (Owner != null)
                {
                    Owner.PerformLayout();
                    Owner.Invalidate();
                }
            }
        }

        /// <summary>
        /// Gets if this panel is currenlty collapsed
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool Collapsed => SizeMode == RibbonElementSizeMode.Overflow;

        /// <summary>
        /// Gets or sets the visibility of the "More" button
        /// </summary>
        [Description("Sets the visibility of the \"More...\" button")]
        [Category("Appearance")]
        [DefaultValue(true)]
        public bool ButtonMoreVisible
        {
            get => _buttonMoreVisible;
            set { _buttonMoreVisible = value; if (Owner != null) Owner.OnRegionsChanged(); }
        }

        /// <summary>
        /// Gets or sets a value indicating if the "More" button should be enabled
        /// </summary>
        [Description(@"Enables/Disables the ""More..."" button")]
        [Category("Appearance")]
        [DefaultValue(true)]
        public bool ButtonMoreEnabled
        {
            get => _buttonMoreEnabled;
            set { _buttonMoreEnabled = value; if (Owner != null) Owner.OnRegionsChanged(); }
        }

        /// <summary>
        /// Gets if the "More" button is currently selected
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ButtonMoreSelected { get; private set; }

        /// <summary>
        /// Gets if the "More" button is currently pressed
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ButtonMorePressed { get; private set; }

        /// <summary>
        /// Gets the bounds of the "More" button
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle ButtonMoreBounds { get; private set; }

        /// <summary>
        /// Gets if the panel is currently on overflow and pressed
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool Pressed { get; private set; }

        /// <summary>
        /// Gets or sets the pop up where the panel is being drawn (if any)
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        internal Control PopUp { get; set; }

        /// <summary>
        /// Gets the current size mode of the panel
        /// </summary>
        [Browsable(false)]
        public RibbonElementSizeMode SizeMode { get; private set; }

        /// <summary>
        /// Gets the collection of RibbonItem elements of this panel
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public RibbonItemCollection Items { get; }

        /// <summary>
        /// Gets or sets the text that is to be displayed on the bottom of the panel
        /// </summary>
        [Category("Appearance")]
        [Localizable(true)]
        public string Text
        {
            get => _text;
            set
            {
                _text = value;

                if (Owner != null) Owner.OnRegionsChanged();
            }
        }

        /// <summary>
        /// Gets or sets the image that is to be displayed on the panel when shown as an overflow button
        /// </summary>
        [DefaultValue(null)]
        [Category("Appearance")]
        public Image Image
        {
            get => _image;
            set
            {
                _image = value;

                if (Owner != null) Owner.OnRegionsChanged();
            }
        }

        /// <summary>
        /// Gets if the panel is in overflow mode
        /// </summary>
        /// <remarks>Overflow mode is when the available space to draw the panel is not enough to draw components, so panel is drawn as a button that shows the full content of the panel in a pop-up window when clicked</remarks>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool OverflowMode => SizeMode == RibbonElementSizeMode.Overflow;

        /// <summary>
        /// Gets the Ribbon that contains this panel
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Ribbon Owner { get; private set; }

        /// <summary>
        /// Gets the bounds of the panel relative to the Ribbon control
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle Bounds { get; private set; }

        /// <summary>
        /// Gets a value indicating whether the panel is selected
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual bool Selected
        {
            get => _selected;
            set => _selected = value;
        }

        /// <summary>
        /// Gets a value indicating whether the panel is the first panel on the tab
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual bool IsFirstPanel { get; set; } = false;

        /// <summary>
        /// Gets a value indicating whether the panel is the last panel on the tab
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual bool IsLastPanel { get; set; } = false;

        /// <summary>
        /// Gets a value indicating what the index of the panel is in the Tabs panel collection
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual int Index { get; set; } = -1;

        /// <summary>
        /// Gets or sets the object that contains data about the control
        /// </summary>
        [Description("An Object field for associating custom data for this control")]
        [DefaultValue(null)]
        [Category("Data")]
        [TypeConverter(typeof(StringConverter))]
        public object Tag { get; set; }

        /// <summary>
        /// Gets the bounds of the content of the panel
        /// </summary>
        [Browsable(false)]
        public Rectangle ContentBounds { get; private set; }

        /// <summary>
        /// Gets the RibbonTab that contains this panel
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public RibbonTab OwnerTab { get; private set; }

        /// <summary>
        /// Gets or sets the flow direction to layout items
        /// </summary>
        [DefaultValue(RibbonPanelFlowDirection.Bottom)]
        [Category("Layout")]
        public RibbonPanelFlowDirection FlowsTo
        {
            get => _flowsTo;
            set
            {
                _flowsTo = value;

                if (Owner != null) Owner.OnRegionsChanged();
            }
        }

        /// <summary>
        /// Gets or sets if the popup is currently showing
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        internal bool PopupShowed { get; set; }

        #endregion

        #region IRibbonElement Members


        public Size SwitchToSize(Control ctl, Graphics g, RibbonElementSizeMode size)
        {
            Size s = MeasureSize(this, new RibbonElementMeasureSizeEventArgs(g, size));
            Rectangle r = new Rectangle(0, 0, s.Width, s.Height);

            //if (!(ctl is Ribbon))
            //    r = boundsBuffer;
            //else
            //    r = new Rectangle(0, 0, 0, 0);

            SetBounds(r);
            UpdateItemsRegions(g, size);
            return s;
        }

        /// <summary>
        /// Raises the paint event and draws the
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public virtual void OnPaint(object sender, RibbonElementPaintEventArgs e)
        {
            if (Paint != null)
            {
                Paint(this, new PaintEventArgs(e.Graphics, e.Clip));
            }

            if (PopupShowed && e.Control == Owner)
            {
                //Draw a fake collapsed and pressed panel

                #region Create fake panel
                RibbonPanel fakePanel = new RibbonPanel(Text)
                {
                    Image = Image
                };
                fakePanel.SetOwner(Owner);
                fakePanel.SetSizeMode(RibbonElementSizeMode.Overflow);
                fakePanel.SetBounds(overflowBoundsBuffer);
                fakePanel.SetPressed(true);
                #endregion

                Owner.Renderer.OnRenderRibbonPanelBackground(new RibbonPanelRenderEventArgs(Owner, e.Graphics, e.Clip, fakePanel, e.Control));
                Owner.Renderer.OnRenderRibbonPanelText(new RibbonPanelRenderEventArgs(Owner, e.Graphics, e.Clip, fakePanel, e.Control));
            }
            else
            {
                //Draw normal
                Owner.Renderer.OnRenderRibbonPanelBackground(new RibbonPanelRenderEventArgs(Owner, e.Graphics, e.Clip, this, e.Control));
                Owner.Renderer.OnRenderRibbonPanelText(new RibbonPanelRenderEventArgs(Owner, e.Graphics, e.Clip, this, e.Control));
            }

            if (e.Mode != RibbonElementSizeMode.Overflow ||
                (e.Control != null && e.Control == PopUp))
            {
                foreach (RibbonItem item in Items)
                {
                    if (item.Visible || Owner.IsDesignMode())
                        item.OnPaint(this, new RibbonElementPaintEventArgs(item.Bounds, e.Graphics, item.SizeMode));
                }
            }
        }

        /// <summary>
        /// Sets the bounds of the panel
        /// </summary>
        /// <param name="bounds"></param>
        public void SetBounds(Rectangle bounds)
        {
            bool trigger = Bounds != bounds;

            Bounds = bounds;

            OnResize(EventArgs.Empty);

            if (Owner != null)
            {
                //Update contentBounds
                ContentBounds = Rectangle.FromLTRB(
                    bounds.X + Owner.PanelMargin.Left + 0,
                    bounds.Y + Owner.PanelMargin.Top + 0,
                    bounds.Right - Owner.PanelMargin.Right,
                    bounds.Bottom - Owner.PanelMargin.Bottom);
            }

            //"More" bounds
            if (ButtonMoreVisible)
            {
                SetMoreBounds(
                    Rectangle.FromLTRB(
                        bounds.Right - Owner.PanelMoreMargin.Right - 15,
                        bounds.Bottom - Owner.PanelMoreMargin.Bottom - 14,
                        bounds.Right - Owner.PanelMoreMargin.Right,
                        bounds.Bottom - Owner.PanelMoreMargin.Bottom)
                    );
            }
            else
            {
                SetMoreBounds(Rectangle.Empty);
            }

        }

        /// <summary>
        /// Measures the size of the panel on the mode specified by the event object
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        public Size MeasureSize(object sender, RibbonElementMeasureSizeEventArgs e)
        {
            Size result = Size.Empty;
            Size minSize = Size.Empty;

            if (!Visible && !Owner.IsDesignMode()) return new Size(0, 0);

            int panelHeight = OwnerTab.TabContentBounds.Height - Owner.PanelPadding.Vertical;

            #region Measure width of minSize

            minSize.Width = e.Graphics.MeasureString(Text, Owner.Font).ToSize().Width + Owner.PanelMargin.Horizontal + 1;

            if (ButtonMoreVisible)
            {
                minSize.Width += ButtonMoreBounds.Width + 3;
            }

            #endregion

            if (e.SizeMode == RibbonElementSizeMode.Overflow)
            {
                Size textSize = RibbonButton.MeasureStringLargeSize(e.Graphics, Text, Owner.Font);

                return new Size(textSize.Width + Owner.PanelMargin.Horizontal, panelHeight);
            }

            switch (FlowsTo)
            {
                case RibbonPanelFlowDirection.Left:
                    result = MeasureSizeFlowsToBottom(sender, e);
                    break;
                case RibbonPanelFlowDirection.Right:
                    result = MeasureSizeFlowsToRight(sender, e);
                    break;
                case RibbonPanelFlowDirection.Bottom:
                    result = MeasureSizeFlowsToBottom(sender, e);
                    break;
                default:
                    result = Size.Empty;
                    break;
            }

            return new Size(Math.Max(result.Width, minSize.Width), panelHeight);
        }

        /// <summary>
        /// Sets the value of the Owner Property
        /// </summary>
        internal void SetOwner(Ribbon owner)
        {
            Owner = owner;

            Items.SetOwner(owner);
        }

        /// <summary>
        /// When an item is removed from the RibbonItemCollection remove all its references.
        /// </summary>
        internal virtual void ClearOwner()
        {
            OwnerTab = null;
            Owner = null;
        }

        /// <summary>
        /// Sets the value of the Selected property
        /// </summary>
        /// <param name="selected">Value that indicates if the element is selected</param>
        internal void SetSelected(bool selected)
        {
            _selected = selected;
        }

        #endregion

        #region Methods

        /// <summary>
        /// Raises the <see cref="Resize"/> method
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnResize(EventArgs e)
        {
            if (Resize != null)
            {
                Resize(this, e);
            }
        }

        /// <summary>
        /// Shows the panel in a popup
        /// </summary>
        private void ShowOverflowPopup()
        {
            Rectangle b = Bounds;
            RibbonPanelPopup f = new RibbonPanelPopup(this);
            Point p = Owner.PointToScreen(new Point(b.Left, b.Bottom));
            PopupShowed = true;
            f.Show(p);
        }

        /// <summary>
        /// Measures the size when flow direction is to right
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Size MeasureSizeFlowsToRight(object sender, RibbonElementMeasureSizeEventArgs e)
        {
            int widthSum = Owner.PanelMargin.Horizontal;
            int maxWidth = 0;
            int maxHeight = 0;
            int dividedWidth = 0;

            foreach (RibbonItem item in Items)
            {
                if (item.Visible || Owner.IsDesignMode())
                {
                    Size itemSize = item.MeasureSize(this, e);

                    widthSum += itemSize.Width + Owner.ItemPadding.Horizontal + 1;

                    maxWidth = Math.Max(maxWidth, itemSize.Width);
                    maxHeight = Math.Max(maxHeight, itemSize.Height);
                }
            }

            switch (e.SizeMode)
            {
                case RibbonElementSizeMode.Large:
                    dividedWidth = widthSum / 1; //Show items on one row
                    break;
                case RibbonElementSizeMode.Medium:
                    dividedWidth = widthSum / 2; //Show items on two rows
                    break;
                case RibbonElementSizeMode.Compact:
                    dividedWidth = widthSum / 3; //Show items on three rows
                    break;
                default:
                    break;
            }

            //Add padding
            dividedWidth += Owner.PanelMargin.Horizontal;

            return new Size(Math.Max(maxWidth, dividedWidth) + Owner.PanelMargin.Horizontal, 0); //Height is provided by MeasureSize
        }

        /// <summary>
        /// Measures the size when flow direction is to bottom
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Size MeasureSizeFlowsToBottom(object sender, RibbonElementMeasureSizeEventArgs e)
        {
            int curRight = Owner.PanelMargin.Left + Owner.ItemPadding.Horizontal;
            int curBottom = ContentBounds.Top + Owner.ItemPadding.Vertical;
            int lastRight = 0;
            int lastBottom = 0;
            int availableHeight = OwnerTab.TabContentBounds.Height - Owner.TabContentMargin.Vertical - Owner.PanelPadding.Vertical - Owner.PanelMargin.Vertical;
            int maxRight = 0;
            int maxBottom = 0;

            foreach (RibbonItem item in Items)
            {
                if (item.Visible || Owner.IsDesignMode() || item.GetType() == typeof(RibbonSeparator))
                {
                    Size itemSize = item.MeasureSize(this, new RibbonElementMeasureSizeEventArgs(e.Graphics, e.SizeMode));

                    if (curBottom + itemSize.Height > ContentBounds.Bottom)
                    {
                        curBottom = ContentBounds.Top + Owner.ItemPadding.Vertical + 0;
                        curRight = maxRight + Owner.ItemPadding.Horizontal + 0;
                    }

                    Rectangle bounds = new Rectangle(curRight, curBottom, itemSize.Width, itemSize.Height);

                    lastRight = bounds.Right;
                    lastBottom = bounds.Bottom;

                    curBottom = bounds.Bottom + Owner.ItemPadding.Vertical + 1;

                    maxRight = Math.Max(maxRight, lastRight);
                    maxBottom = Math.Max(maxBottom, lastBottom);
                }
            }

            return new Size(maxRight + Owner.ItemPadding.Right + Owner.PanelMargin.Right + 1, 0); //Height is provided by MeasureSize
        }

        /// <summary>
        /// Sets the value of the SizeMode property
        /// </summary>
        /// <param name="sizeMode"></param>
        internal void SetSizeMode(RibbonElementSizeMode sizeMode)
        {
            SizeMode = sizeMode;

            foreach (RibbonItem item in Items)
            {
                item.SetSizeMode(sizeMode);
            }
        }

        /// <summary>
        /// Sets the value of the ContentBounds property
        /// </summary>
        /// <param name="contentBounds">Bounds of the content on the panel</param>
        internal void SetContentBounds(Rectangle contentBounds)
        {
            ContentBounds = contentBounds;
        }

        /// <summary>
        /// Sets the value of the OwnerTab property
        /// </summary>
        /// <param name="ownerTab">RibbonTab where this item is located</param>
        internal void SetOwnerTab(RibbonTab ownerTab)
        {
            OwnerTab = ownerTab;

            Items.SetOwnerTab(OwnerTab);
        }

        /// <summary>
        /// Updates the bounds of child elements
        /// </summary>
        internal void UpdateItemsRegions(Graphics g, RibbonElementSizeMode mode)
        {
            switch (FlowsTo)
            {
                case RibbonPanelFlowDirection.Right:
                    UpdateRegionsFlowsToRight(g, mode);
                    break;
                case RibbonPanelFlowDirection.Bottom:
                    UpdateRegionsFlowsToBottom(g, mode);
                    break;
                case RibbonPanelFlowDirection.Left:
                    UpdateRegionsFlowsToLeft(g, mode);
                    break;
            }

            //Center items on the panel
            CenterItems();
        }

        /// <summary>
        /// Updates the bounds of child elements when flow is to bottom
        /// </summary>
        private void UpdateRegionsFlowsToBottom(Graphics g, RibbonElementSizeMode mode)
        {
            int curRight = ContentBounds.Left + Owner.ItemPadding.Horizontal + 0;
            int curBottom = ContentBounds.Top + Owner.ItemPadding.Vertical + 0;
            int lastRight = curRight;
            int lastBottom = 0;
            List<RibbonItem> lastColumn = new List<RibbonItem>();

            //Iterate thru items on panel
            foreach (RibbonItem item in Items)
            {
                //Gets the last measured size (to avoid re-measuring calculations)
                Size itemSize;
                if (item.Visible || Owner.IsDesignMode())
                    itemSize = item.LastMeasuredSize;
                else
                    itemSize = new Size(0, 0);

                //If not enough space available, reset curBottom and advance curRight
                if (curBottom + itemSize.Height > ContentBounds.Bottom)
                {
                    curBottom = ContentBounds.Top + Owner.ItemPadding.Vertical + 0;
                    curRight = lastRight + Owner.ItemPadding.Horizontal + 0;
                    Items.CenterItemsVerticallyInto(lastColumn, ContentBounds);
                    lastColumn.Clear();
                }

                //Set the item's bounds
                item.SetBounds(new Rectangle(curRight, curBottom, itemSize.Width, itemSize.Height));

                //save last right and bottom
                lastRight = Math.Max(item.Bounds.Right, lastRight);
                lastBottom = item.Bounds.Bottom;

                //update current bottom
                curBottom = item.Bounds.Bottom + Owner.ItemPadding.Vertical + 1;

                //Add to the collection of items of the last column
                lastColumn.Add(item);
            }

            //Center the items vertically on the last column 
            Items.CenterItemsVerticallyInto(lastColumn, ContentBounds);
        }

        /// <summary>
        /// Updates the bounds of child elements when flow is to Left.
        /// </summary>
        private void UpdateRegionsFlowsToLeft(Graphics g, RibbonElementSizeMode mode)
        {
            int curRight = ContentBounds.Left + Owner.ItemPadding.Horizontal + 0;
            int curBottom = ContentBounds.Top + Owner.ItemPadding.Vertical + 0;
            int lastRight = curRight;
            int lastBottom = 0;
            List<RibbonItem> lastColumn = new List<RibbonItem>();

            //Iterate thru items on panel
            for (int i = Items.Count - 1; i >= 0; i--)
            {
                RibbonItem item = Items[i];

                //Gets the last measured size (to avoid re-measuring calculations)
                Size itemSize;
                if (item.Visible)
                    itemSize = item.LastMeasuredSize;
                else
                    itemSize = new Size(0, 0);

                //If not enough space available, reset curBottom and advance curRight
                if (curBottom + itemSize.Height > ContentBounds.Bottom)
                {
                    curBottom = ContentBounds.Top + Owner.ItemPadding.Vertical + 0;
                    curRight = lastRight + Owner.ItemPadding.Horizontal + 0;
                    Items.CenterItemsVerticallyInto(lastColumn, ContentBounds);
                    lastColumn.Clear();
                }

                //Set the item's bounds
                item.SetBounds(new Rectangle(curRight, curBottom, itemSize.Width, itemSize.Height));

                //save last right and bottom
                lastRight = Math.Max(item.Bounds.Right, lastRight);
                lastBottom = item.Bounds.Bottom;

                //update current bottom
                curBottom = item.Bounds.Bottom + Owner.ItemPadding.Vertical + 1;

                //Add to the collection of items of the last column
                lastColumn.Add(item);
            }

            //Center the items vertically on the last column 
            Items.CenterItemsVerticallyInto(lastColumn, Items.GetItemsBounds());
        }

        /// <summary>
        /// Updates the bounds of child elements when flow is to bottom
        /// </summary>
        private void UpdateRegionsFlowsToRight(Graphics g, RibbonElementSizeMode mode)
        {
            int curLeft = ContentBounds.Left;
            int curTop = ContentBounds.Top;
            int padding = mode == RibbonElementSizeMode.Medium ? 7 : 0;
            int maxBottom = 0;

            #region Sorts from larger to smaller

            RibbonItem[] array = Items.ToArray();

            for (int i = (array.Length - 1); i >= 0; i--)
            {
                for (int j = 1; j <= i; j++)
                {
                    if (array[j - 1].LastMeasuredSize.Width < array[j].LastMeasuredSize.Width)
                    {
                        RibbonItem temp = array[j - 1];
                        array[j - 1] = array[j];
                        array[j] = temp;
                    }
                }
            }

            #endregion

            List<RibbonItem> list = new List<RibbonItem>(array);

            //Attend elements, deleting every attended element from the list
            while (list.Count > 0)
            {
                //Extract item and delete it
                RibbonItem item = list[0];
                list.Remove(item);

                //If not enough space left, reset left and advance top
                if (curLeft + item.LastMeasuredSize.Width > ContentBounds.Right)
                {
                    curLeft = ContentBounds.Left;
                    curTop = maxBottom + Owner.ItemPadding.Vertical + 1 + padding;
                }

                //Set item's bounds
                item.SetBounds(new Rectangle(new Point(curLeft, curTop), item.LastMeasuredSize));

                //Increment reminders
                curLeft += item.Bounds.Width + Owner.ItemPadding.Horizontal;
                maxBottom = Math.Max(maxBottom, item.Bounds.Bottom);

                //Check available space after placing item
                int spaceAvailable = ContentBounds.Right - curLeft;

                //Check for elements that fit on available space
                for (int i = 0; i < list.Count; i++)
                {
                    //If item fits on the available space
                    if (list[i].LastMeasuredSize.Width < spaceAvailable)
                    {
                        //Place the item there and reset the counter to check for further items
                        list[i].SetBounds(new Rectangle(new Point(curLeft, curTop), list[i].LastMeasuredSize));
                        curLeft += list[i].Bounds.Width + Owner.ItemPadding.Horizontal;
                        maxBottom = Math.Max(maxBottom, list[i].Bounds.Bottom);
                        spaceAvailable = ContentBounds.Right - curLeft;
                        list.RemoveAt(i);
                        i = 0;
                    }
                }
            }
        }

        /// <summary>
        /// Centers the items on the tab conent
        /// </summary>
        private void CenterItems()
        {
            Items.CenterItemsInto(ContentBounds);
        }

        /// <summary>
        /// Overriden. Gives info about the panel as a string
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format("Panel: {0} ({1})", Text, SizeMode);
        }

        /// <summary>
        /// Sets the value of the Pressed property
        /// </summary>
        /// <param name="pressed"></param>
        public void SetPressed(bool pressed)
        {
            Pressed = pressed;
        }

        /// <summary>
        /// Sets the value of the ButtonMorePressed property
        /// </summary>
        /// <param name="pressed">property value</param>
        internal void SetMorePressed(bool pressed)
        {
            ButtonMorePressed = pressed;
        }

        /// <summary>
        /// Sets the value of the ButtonMoreSelected property
        /// </summary>
        /// <param name="selected">property value</param>
        internal void SetMoreSelected(bool selected)
        {
            ButtonMoreSelected = selected;
        }

        /// <summary>
        /// Sets the value of the ButtonMoreBounds property
        /// </summary>
        /// <param name="bounds">property value</param>
        internal void SetMoreBounds(Rectangle bounds)
        {
            ButtonMoreBounds = bounds;
        }

        /// <summary>
        /// Raised the <see cref="ButtonMoreClick"/> event
        /// </summary>
        /// <param name="e"></param>
        protected void OnButtonMoreClick(EventArgs e)
        {
            if (ButtonMoreClick != null)
            {
                ButtonMoreClick(this, e);
            }
        }

        #endregion

        #region IContainsRibbonItems Members

        public IEnumerable<RibbonItem> GetItems()
        {
            return Items;
        }

        public Rectangle GetContentBounds()
        {
            return ContentBounds;
        }

        /// <summary>
        /// Raises the MouseEnter event
        /// </summary>
        /// <param name="e">Event data</param>
        public virtual void OnMouseEnter(MouseEventArgs e)
        {
            if (!Enabled) return;

            if (MouseEnter != null)
            {
                MouseEnter(this, e);
            }
        }

        /// <summary>
        /// Raises the MouseLeave event
        /// </summary>
        /// <param name="e">Event data</param>
        public virtual void OnMouseLeave(MouseEventArgs e)
        {
            if (!Enabled) return;

            if (MouseLeave != null)
            {
                MouseLeave(this, e);
            }
        }

        /// <summary>
        /// Raises the MouseMove event
        /// </summary>
        /// <param name="e">Event data</param>
        public virtual void OnMouseMove(MouseEventArgs e)
        {
            if (!Enabled) return;

            if (MouseMove != null)
            {
                MouseMove(this, e);
            }

            bool redraw = false;

            if (ButtonMoreEnabled && ButtonMoreVisible && ButtonMoreBounds.Contains(e.X, e.Y) && !Collapsed)
            {
                SetMoreSelected(true);
                redraw = true;
            }
            else
            {
                redraw = ButtonMoreSelected;
                SetMoreSelected(false);
            }

            if (redraw)
            {
                Owner.Invalidate(Bounds);
            }
        }

        /// <summary>
        /// Raises the Click event
        /// </summary>
        /// <param name="e">Event data</param>
        public virtual void OnClick(EventArgs e)
        {
            if (!Enabled) return;

            if (Click != null)
            {
                Click(this, e);
            }

            if (Collapsed && PopUp == null)
            {
                ShowOverflowPopup();
            }
        }

        /// <summary>
        /// Raises the DoubleClick event
        /// </summary>
        /// <param name="e">Event data</param>
        public virtual void OnDoubleClick(EventArgs e)
        {
            if (!Enabled) return;

            if (DoubleClick != null)
            {
                DoubleClick(this, e);
            }
        }

        /// <summary>
        /// Raises the MouseDown event
        /// </summary>
        /// <param name="e">Event data</param>
        public virtual void OnMouseDown(MouseEventArgs e)
        {
            if (!Enabled) return;

            if (MouseDown != null)
            {
                MouseDown(this, e);
            }

            SetPressed(true);

            bool redraw = false;

            if (ButtonMoreEnabled && ButtonMoreVisible && ButtonMoreBounds.Contains(e.X, e.Y) && !Collapsed)
            {
                SetMorePressed(true);
                redraw = true;
            }
            else
            {
                redraw = ButtonMoreSelected;
                SetMorePressed(false);
            }

            if (redraw)
            {
                Owner.Invalidate(Bounds);
            }
        }

        /// <summary>
        /// Raises the MouseUp event
        /// </summary>
        /// <param name="e">Event data</param>
        public virtual void OnMouseUp(MouseEventArgs e)
        {
            if (!Enabled) return;

            if (MouseUp != null)
            {
                MouseUp(this, e);
            }

            if (ButtonMoreEnabled && ButtonMoreVisible && ButtonMorePressed && !Collapsed)
            {
                OnButtonMoreClick(EventArgs.Empty);
            }

            SetPressed(false);
            SetMorePressed(false);
        }

        #endregion

        #region IContainsRibbonComponents Members

        public IEnumerable<Component> GetAllChildComponents()
        {
            return Items.ToArray();
        }

        #endregion
    }
}