using System;
using System.Text;
using System.ComponentModel;
using System.Drawing;
using DevComponents.UI.ContentManager;
using System.Collections;
using System.Drawing.Drawing2D;

namespace DevComponents.DotNetBar
{
    /// <summary>
    /// Represents the class that provides Office 2007 style Gallery container with drop-down ability.
    /// </summary>
    [ToolboxItem(false), DesignTimeVisible(false), ProvideProperty("GalleryGroup", typeof(BaseItem)), Designer("DevComponents.DotNetBar.Design.GalleryContainerDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf")]
    public class GalleryContainer : ItemContainer, IExtenderProvider
    {
        #region Private Variables
        private bool m_EnableGalleryPopup = true;
        private ButtonItem m_ScrollUp = null;
        private ButtonItem m_ScrollDown = null;
        private ButtonItem m_PopupGallery = null;
        private Size m_ScrollButtonSize = new Size(15, 20);
        private int m_ScrollButtonContentSpacing = 1;
        private Size m_DefaultSize = Size.Empty;
        private Point m_ScrollPosition = Point.Empty;
        private Size m_PopupGallerySize = Size.Empty;
        private ScrollBar.ScrollBarCore m_ScrollBar = null;
        private bool m_PopupGalleryStyle = false;
        private Rectangle m_ViewRectangle = Rectangle.Empty;
        private Size m_RecommendedSize = Size.Empty;
        private bool m_StretchGallery = false;
        internal bool SystemGallery = false;
        private bool m_IncrementalSizing = true;
        private GalleryGroupCollection m_Groups = null;
        private bool m_ScrollAnimation = true;
        private ThreadUIOperation m_ThreadUI = null;
        private bool m_PopupUsesStandardScrollbars = true;
        #endregion

        #region Events
        /// <summary>
        /// Occurs when Gallery popup item is about to open.
        /// </summary>
        [System.ComponentModel.Description("Occurs when Gallery popup item is about to open.")]
        public event DotNetBarManager.PopupOpenEventHandler GalleryPopupOpen;

        /// <summary>
        /// Occurs just before Gallery popup window is shown.
        /// </summary>
        [System.ComponentModel.Description("Occurs just before Gallery popup window is shown.")]
        public event EventHandler GalleryPopupShowing;

        /// <summary>
        /// Occurs before the Gallery popup item is closed.
        /// </summary>
        [System.ComponentModel.Description("Occurs before the Gallery popup item is closed")]
        public event EventHandler GalleryPopupClose;

        /// <summary>
        /// Occurs after Gallery popup item has been closed.
        /// </summary>
        [System.ComponentModel.Description("Occurs after popup item has been closed.")]
        public event EventHandler GalleryPopupFinalized;
        #endregion

        #region Constructor
        /// <summary>
        /// Creates new instance of the class
        /// </summary>
        public GalleryContainer()
            : base()
        {
            m_DefaultSize = GetDefaultSize();
            m_PopupGallerySize = GetDefaultPopupSize();
            m_Groups = new GalleryGroupCollection();
            m_Groups.Owner = this;
            this.MultiLine = true;
            //this.BackgroundStyle.Class = Rendering.ElementStyleClassKeys.RibbonGalleryContainerKey;
            CreateButtons();
            this.MinimumSize = new Size(Dpi.Width(42 + m_ScrollButtonSize.Width + m_ScrollButtonContentSpacing), Dpi.Height(m_DefaultSize.Height));
            m_ThreadUI = new ThreadUIOperation(new EventHandler(this.RecordStartState), new EventHandler(this.UpdateThreadedUI), new EventHandler(this.CleanupState));
        }

        private Size GetDefaultSize()
        {
            return new Size(140 + m_ScrollButtonSize.Width + m_ScrollButtonContentSpacing, m_ScrollButtonSize.Height * 3 - 2);
        }

        private Size GetDefaultPopupSize()
        {
            return Size.Empty;
        }

        /// <summary>
        /// Returns copy of the item.
        /// </summary>
        public override BaseItem Copy()
        {
            GalleryContainer objCopy = new GalleryContainer();
            this.CopyToItem(objCopy);
            return objCopy;
        }
        /// <summary>
        /// Copies the ButtonItem specific properties to new instance of the item.
        /// </summary>
        /// <param name="c">New ButtonItem instance.</param>
        protected override void CopyToItem(BaseItem c)
        {
            GalleryContainer copy = c as GalleryContainer;
            copy.DefaultSize = this.DefaultSize;
            copy.PopupGallerySize = this.PopupGallerySize;
            copy.StretchGallery = this.StretchGallery;
            copy.PopupUsesStandardScrollbars = this.PopupUsesStandardScrollbars;

            foreach (BaseItem item in this.PopupGalleryItems)
                copy.PopupGalleryItems.Add(item.Copy());

            base.CopyToItem(copy);

            foreach (BaseItem item in copy.SubItems)
            {
                item.CollapseAllBeforeRaisingClick = false; // This ensures that item is not disposed (Command then set to null) before its click event is raised and command executed
            }

            // Copy Gallery Groups
            foreach (GalleryGroup group in this.GalleryGroups)
            {
                GalleryGroup groupCopy = new GalleryGroup();
                groupCopy.Name = group.Name;
                groupCopy.Text = group.Text;
                groupCopy.DisplayOrder = group.DisplayOrder;
                copy.GalleryGroups.Add(groupCopy);

                foreach (BaseItem item in group.Items)
                {
                    copy.SetGalleryGroup(copy.SubItems[item.Name], groupCopy);
                }
            }
        }

        protected override void Dispose(bool disposing)
        {
            m_ScrollUp.Click -= ScrollUp_Click;
            m_ScrollDown.Click -= ScrollDown_Click;
            m_PopupGallery.Click -= PopupGallery_Click;
            m_PopupGallery.PopupOpen -= PopupGallery_PopupOpen;
            m_PopupGallery.PopupShowing -= PopupGallery_PopupShowing;
            m_PopupGallery.PopupClose -= PopupGallery_PopupClose;
            m_PopupGallery.PopupFinalized -= PopupGallery_PopupFinalized;

            if (m_ScrollBar != null)
            {
                m_ScrollBar.Dispose();
                m_ScrollBar = null;
            }
            m_ThreadUI.Stop();
            base.Dispose(disposing);
        }

        private void CreateButtons()
        {
            m_ScrollUp = new ButtonItem("sysgalleryscrollup");
            m_ScrollUp.Text = "<expand direction=\"top\"/>";
            m_ScrollUp.Style = this.Style;
            m_ScrollUp.ColorTable = eButtonColor.OrangeWithBackground;
            m_ScrollUp.SetParent(this);
            m_ScrollUp.Click += new EventHandler(ScrollUp_Click);
            m_ScrollUp.ClickAutoRepeat = true;
            m_ScrollUp.ClickRepeatInterval = 200;
            m_ScrollUp.CanCustomize = false;
            m_ScrollUp.AutoCollapseOnClick = false;

            m_ScrollDown = new ButtonItem("sysgalleryscrolldown");
            m_ScrollDown.Text = "<expand direction=\"bottom\"/>";
            m_ScrollDown.Style = this.Style;
            m_ScrollDown.ColorTable = eButtonColor.OrangeWithBackground;
            m_ScrollDown.SetParent(this);
            m_ScrollDown.Click += new EventHandler(ScrollDown_Click);
            m_ScrollDown.ClickAutoRepeat = true;
            m_ScrollDown.ClickRepeatInterval = 200;
            m_ScrollDown.CanCustomize = false;
            m_ScrollDown.AutoCollapseOnClick = false;

            m_PopupGallery = new ButtonItem("sysgallerypopup");
            m_PopupGallery.Text = "<expand direction=\"popup\"/>";
            m_PopupGallery.ButtonStyle = eButtonStyle.TextOnlyAlways;
            m_PopupGallery.Style = this.Style;
            m_PopupGallery.ColorTable = eButtonColor.OrangeWithBackground;
            m_PopupGallery.SetParent(this);
            m_PopupGallery.Click += new EventHandler(PopupGallery_Click);
            m_PopupGallery.CanCustomize = false;
            m_PopupGallery.PopupOpen += new DotNetBarManager.PopupOpenEventHandler(PopupGallery_PopupOpen);
            m_PopupGallery.PopupShowing += new EventHandler(PopupGallery_PopupShowing);
            m_PopupGallery.PopupClose += new EventHandler(PopupGallery_PopupClose);
            m_PopupGallery.PopupFinalized += new EventHandler(PopupGallery_PopupFinalized);
        }

        private void PopupGallery_PopupShowing(object sender, EventArgs e)
        {
            OnGalleryPopupShowing(sender, e);
        }

        private void PopupGallery_PopupOpen(object sender, PopupOpenEventArgs e)
        {
            OnGalleryPopupOpen(sender, e);
        }
        
        private void PopupGallery_Click(object sender, EventArgs e)
        {
            PopupGallery();
        }

        private Size GetPopupGallerySize(Point screenPos)
        {
            Size size = Size.Empty;
            if (this.DisplayRectangle.Width < this.DefaultSize.Width || m_ViewRectangle.Size.IsEmpty)
            {
                int width = this.DefaultSize.Width;
                int itemBasedWidth = 0;
                foreach (BaseItem item in this.SubItems)
                {
                    if (!item.Visible) continue;
                    itemBasedWidth += item.WidthInternal + this.ItemSpacing;
                    if (itemBasedWidth > width)
                        break;
                }
                if (itemBasedWidth > 0)
                {
                    width = itemBasedWidth;
                    if (m_PopupUsesStandardScrollbars)
                        width += Dpi.Width(m_ScrollButtonContentSpacing + m_ScrollButtonSize.Width);
                }
                size = new Size(width, Math.Max(this.DefaultSize.Height, m_ViewRectangle.Height));
            }
            else
                size = new Size(this.DisplayRectangle.Width, m_ViewRectangle.Height);

            ScreenInformation screenInfo = null;
            screenInfo = BarFunctions.ScreenFromPoint(screenPos);
            
            // Give the grouped gallery max size since we do not know yet how tall it is
            if (m_Groups.Count > 0 && screenInfo!=null && screenInfo.WorkingArea.Bottom - screenPos.Y>size.Height)
            {
                size.Height = screenInfo.WorkingArea.Bottom - screenPos.Y;
            }

            if (screenInfo != null)
            {
                int red = 16;
                red += this.PopupGalleryItems.Count * 26;
                int yDiff= 0, xDiff = 0;
                if (screenPos.Y + size.Height > screenInfo.WorkingArea.Bottom - red)
                    yDiff = screenPos.Y + size.Height - (screenInfo.WorkingArea.Bottom - red);
                if (screenPos.X + size.Width > screenInfo.WorkingArea.Right - red)
                    xDiff = screenPos.X + size.Width - (screenInfo.WorkingArea.Right - red);
                if (size.Width - xDiff > this.MinimumSize.Width)
                    size.Width -= xDiff;
                else
                    size.Width = this.MinimumSize.Width + Dpi.Width(m_ScrollButtonContentSpacing + m_ScrollButtonSize.Width);
                if (size.Height - yDiff > this.MinimumSize.Height)
                    size.Height -= yDiff;
                else
                    size.Height = this.MinimumSize.Height;
            }

            return size;
        }

        internal bool PopupGalleryStyle
        {
            get { return m_PopupGalleryStyle; }
            set
            {
                m_PopupGalleryStyle = value;
                
                if (m_ScrollBar != null)
                {
                    m_ScrollBar.Dispose();
                    m_ScrollBar = null;
                }

                if (m_PopupGalleryStyle)
                {
                    if (m_PopupUsesStandardScrollbars)
                    {
                        m_ScrollBar = new ScrollBar.ScrollBarCore();
                        m_ScrollBar.ValueChanged += new EventHandler(PopupScrollBar_ValueChanged);
                    }
                }
            }
        }

        ///// <summary>
        ///// Adds the items that are not visible to the overflow popup.
        ///// </summary>
        //private void AddItems(GalleryContainer c)
        //{
        //    BaseItem[] items = new BaseItem[this.SubItems.Count];
        //    this.SubItems.CopyTo(items, 0);
        //    foreach (BaseItem objItem in items)
        //    {
        //        c.SubItems._Add(objItem);
        //        this.SubItems._Remove(objItem);
        //        objItem.SetParent(c);
        //        objItem.ContainerControl = null;
        //    }

        //    items = new BaseItem[m_PopupGalleryItems.Count];
        //    m_PopupGalleryItems.CopyTo(items, 0);
        //    foreach (BaseItem objItem in items)
        //    {
        //        m_PopupGallery.SubItems._Add(objItem);
        //        m_PopupGalleryItems._Remove(objItem);
        //        objItem.SetParent(c);
        //        objItem.ContainerControl = null;
        //    }

        //    c.NeedRecalcSize = true;
        //}

        private void ClearPopupGalleryItems()
        {
            if (!this.DesignMode)
            {
                // When copy is made this ensures the proper cleanup
                foreach (BaseItem item in m_PopupGallery.SubItems)
                {
                    GalleryContainer gc = item as GalleryContainer;
                    if (gc != null && gc.SystemGallery)
                    {
                        m_PopupGallery.SubItems.Remove(gc);
                        gc.Dispose();
                        break;
                    }
                }
            }
        }

        private void PopupGallery_PopupFinalized(object sender, EventArgs e)
        {
            OnGalleryPopupFinalized(sender, e);
            ClearPopupGalleryItems();
        }

        private void PopupGallery_PopupClose(object sender, EventArgs e)
        {
            OnGalleryPopupClose(sender, e);
            RestoreGalleryItems();
        }

        private void RestoreGalleryItems()
        {
            //GalleryContainer c = m_PopupGallery.SubItems[0] as GalleryContainer;
            //if (c == null) return;
            //BaseItem[] items = new BaseItem[c.SubItems.Count];
            //c.SubItems.CopyTo(items, 0);
            //foreach (BaseItem item in items)
            //{
            //    this.SubItems._Add(item);
            //    c.SubItems._Remove(item);
            //    item.SetParent(this);
            //    item.ContainerControl = null;
            //}

            //for (int i = 1; i < m_PopupGallery.SubItems.Count; i++)
            //{
            //    BaseItem item = m_PopupGallery.SubItems[i];
            //    m_PopupGalleryItems._Add(item);
            //    item.SetParent(this);
            //    item.ContainerControl = null;
            //}

            //m_PopupGallery.SubItems._Clear();
            //this.NeedRecalcSize = true;
        }

        private void ScrollUp_Click(object sender, EventArgs e)
        {
            this.ScrollUp();
        }

        private void ScrollDown_Click(object sender, EventArgs e)
        {
            this.ScrollDown();
        }

        internal bool ScrollHitTest(int x, int y)
        {
            if (m_ScrollUp.Enabled && m_ScrollUp.DisplayRectangle.Contains(x, y))
                return true;
            else if (m_ScrollDown.Enabled && m_ScrollDown.DisplayRectangle.Contains(x,y))
                return true;
            else if (m_ScrollBar != null && m_ScrollBar.Visible)
            {
                if (m_ScrollBar.ThumbIncreaseRectangle.Contains(x,y))
                    return true;
                else if (m_ScrollBar.ThumbDecreaseRectangle.Contains(x,y))
                    return true;
            }
            return false;
        }

        private bool m_MouseDownOnScrollBar = false;
        public override void InternalMouseDown(System.Windows.Forms.MouseEventArgs objArg)
        {
            if (this.IsDisposed) return;

            m_MouseDownOnScrollBar = false;
            if (m_PopupGalleryStyle && m_PopupUsesStandardScrollbars)
            {
                m_ScrollBar.MouseDown(objArg);
                if (m_ScrollBar.DisplayRectangle.Contains(objArg.X, objArg.Y))
                    m_MouseDownOnScrollBar = true;
            }

            base.InternalMouseDown(objArg);

            if (this.DesignMode)
            {
                if (m_ScrollUp.Enabled && m_ScrollUp.DisplayRectangle.Contains(objArg.X, objArg.Y))
                    ScrollUp();
                else if (m_ScrollDown.Enabled && m_ScrollDown.DisplayRectangle.Contains(objArg.X, objArg.Y))
                    ScrollDown();
                else if (m_PopupGallery.Enabled && m_PopupGallery.DisplayRectangle.Contains(objArg.X, objArg.Y))
                    PopupGallery();
                else if (m_ScrollBar != null && m_ScrollBar.Visible)
                {
                    if(m_ScrollBar.ThumbIncreaseRectangle.Contains(objArg.X, objArg.Y))
                        ScrollDown();
                    else if (m_ScrollBar.ThumbDecreaseRectangle.Contains(objArg.X, objArg.Y))
                        ScrollUp();
                }
            }
        }

        public override void InternalMouseMove(System.Windows.Forms.MouseEventArgs objArg)
        {
            if (m_PopupGalleryStyle && !this.IsDisposed)
            {
                if (m_PopupUsesStandardScrollbars)
                    m_ScrollBar.MouseMove(objArg);
            }

            base.InternalMouseMove(objArg);
        }

        public override void InternalMouseUp(System.Windows.Forms.MouseEventArgs objArg)
        {
            if (m_PopupGalleryStyle && m_PopupUsesStandardScrollbars && !this.IsDisposed)
            {
                m_ScrollBar.MouseUp(objArg);
                if (m_ScrollBar.DisplayRectangle.Contains(objArg.X, objArg.Y) || m_MouseDownOnScrollBar)
                {
                    m_MouseDownOnScrollBar = false;
                    return;
                }
            }
            base.InternalMouseUp(objArg);
        }

        public override void InternalMouseLeave()
        {
            if (m_PopupGalleryStyle && !this.IsDisposed)
            {
                if (m_PopupUsesStandardScrollbars)
                    m_ScrollBar.MouseLeave();
                //else
                //{
                //    if (m_ScrollUp.IsMouseOver)
                //        m_ScrollUp.InternalMouseLeave();
                //    if (m_ScrollDown.IsMouseOver)
                //        m_ScrollDown.InternalMouseLeave();
                //}
            }
            base.InternalMouseLeave();
        }

        public override void InternalKeyDown(System.Windows.Forms.KeyEventArgs objArg)
        {
            if (this.IsGalleryPopupOpen)
            {
                m_PopupGallery.InternalKeyDown(objArg);
                return;
            }

            //BaseItem oldHotSubItem = this.HotSubItem;
            base.InternalKeyDown(objArg);
            // Check whether new hot item is out of bounds and if it is scroll it into the view
            //Rectangle displayRect = GetClientRectangle();
            //if (this.HotSubItem != oldHotSubItem && this.HotSubItem != null && !displayRect.Contains(this.HotSubItem.Bounds))
            //{
            //    EnsureVisible(this.HotSubItem);
            //}
        }

        protected override void OnHotSubItemChanged(BaseItem newValue, BaseItem oldValue)
        {
            base.OnHotSubItemChanged(newValue, oldValue);

            if (newValue != null && newValue != oldValue)
            {
                Rectangle displayRect = GetClientRectangle();
                if (!displayRect.Contains(newValue.Bounds))
                {
                    EnsureVisible(newValue);
                }
            }
        }

        /// <summary>
        /// Returns the client rectangle which is DisplayRectangle excluding scroll-bar bounds
        /// </summary>
        /// <returns></returns>
        private Rectangle GetClientRectangle()
        {
            Rectangle r = this.DisplayRectangle;
            if (m_ScrollBar != null)
                r.Width -= m_ScrollBar.DisplayRectangle.Width;

            if (m_PopupGalleryStyle && !m_PopupUsesStandardScrollbars)
            {
                if (m_ScrollUp != null)
                {
                    r.Y += m_ScrollUp.HeightInternal;
                    r.Height -= m_ScrollUp.HeightInternal;
                }
                if (m_ScrollDown != null)
                {
                    r.Height -= m_ScrollDown.HeightInternal;
                }
            }
            else
            {
                if (m_ScrollUp != null)
                    r.Width -= m_ScrollUp.WidthInternal;
            }

            return r;
        }

        internal Size RecommendedSize
        {
            get { return m_RecommendedSize;  }
            set { m_RecommendedSize = value;  }
        }

        /// <summary>
        /// Invokes GalleryPopupOpen event.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnGalleryPopupOpen(object sender, PopupOpenEventArgs e)
        {
            if (GalleryPopupOpen != null)
                GalleryPopupOpen(sender, e);
        }

        /// <summary>
        /// Invokes GalleryPopupShowing event.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnGalleryPopupShowing(object sender, EventArgs e)
        {
            if (GalleryPopupShowing != null)
                GalleryPopupShowing(sender, e);
        }

        /// <summary>
        /// Invokes GalleryPopupClose event.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnGalleryPopupClose(object sender, EventArgs e)
        {
            if (GalleryPopupClose != null)
                GalleryPopupClose(sender, e);
        }

        /// <summary>
        /// Invokes GalleryPopupFinalized event.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnGalleryPopupFinalized(object sender, EventArgs e)
        {
            if (GalleryPopupFinalized != null)
                GalleryPopupFinalized(sender, e);
        }
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle PopupGalleryButtonBounds
        {
            get { return m_PopupGallery.DisplayRectangle; }
        }
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ButtonItem PopupGalleryItem
        {
            get { return m_PopupGallery; }
        }
        #endregion

        #region Property Hidding
        /// <summary>
        /// Gets or sets orientation inside the container. GalleryContainer automatically manages the layout orientation and this property should not be changed from its default value.
        /// </summary>
        [Browsable(false), DefaultValue(eOrientation.Horizontal), DesignerSerializationVisibility(DesignerSerializationVisibility.Visible), Category("Layout")]
        public override eOrientation LayoutOrientation
        {
            get { return base.LayoutOrientation; }
            set { base.LayoutOrientation = value; }
        }

        /// <summary>
        /// Gets or sets the item alignment when container is in horizontal layout. Default value is Left.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
        public override eHorizontalItemsAlignment HorizontalItemAlignment
        {
            get { return base.HorizontalItemAlignment; }
            set { base.HorizontalItemAlignment = value; }
        }

        /// <summary>
        /// Gets or sets the item vertical alignment. Default value is Top.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
        public override eVerticalItemsAlignment VerticalItemAlignment
        {
            get { return base.VerticalItemAlignment; }
            set { base.VerticalItemAlignment = value; }
        }

        /// <summary>
        /// Gets or sets whether items in horizontal layout are wrapped into the new line when they cannot fit allotted container size. Default value is false.
        /// </summary>
        [Browsable(true), DefaultValue(true), Category("Layout"), Description("Indicates whether items in horizontal layout are wrapped into the new line when they cannot fit allotted container size.")]
        public override bool MultiLine
        {
            get { return base.MultiLine; }
            set { base.MultiLine = value; }
        }

        /// <summary>
        /// Gets or sets whether items contained by container are resized to fit the container bounds. When container is in horizontal
        /// layout mode then all items will have the same height. When container is in vertical layout mode then all items
        /// will have the same width. Default value is true.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
        public override bool ResizeItemsToFit
        {
            get { return base.ResizeItemsToFit; }
            set { base.ResizeItemsToFit = value; }
        }
        #endregion

        #region Public Interface
        /// <summary>
        /// Gets or sets whether Gallery when on popup is using standard scrollbars to scroll the content.
        /// Standard scrollbars are displayed on right hand side of the Gallery. Default value for this property is true.
        /// When set to false the scroll buttons are displayed only when needed and two buttons on top and bottom
        /// of the Gallery are used to indicate the scrolling possibility and enable scrolling. Buttons are only
        /// visible when needed. This scrolling button style can be used for example on Application Menu
        /// to enable scrolling of list of most recently used files.
        /// </summary>
        [Browsable(true), Category("Appearance"), DefaultValue(true), Description("Indicates whether Gallery when on popup is using standard scrollbars to scroll the content.")]
        public bool PopupUsesStandardScrollbars
        {
            get { return m_PopupUsesStandardScrollbars; }
            set
            {
                m_PopupUsesStandardScrollbars = value;
            }
        }

        /// <summary>
        /// Gets or sets whether gallery is using incremental sizing when stretched. Default
        /// value is true. Incremental sizing will resize the width of the gallery so it fits
        /// completely the items it can contain in available space. That means that gallery will
        /// occupy enough space to display the whole items within available space. When set to
        /// false, it indicates that gallery will resize to fill all available space.
        /// </summary>
        [Browsable(true), DefaultValue(true), Category("Layout"), Description("Indicates whether gallery is using incremental sizing when stretched.")]
        public bool IncrementalSizing
        {
            get { return m_IncrementalSizing; }
            set
            {
                m_IncrementalSizing = value;
                this.NeedRecalcSize = true;
                OnAppearanceChanged();
            }
        }

        /// <summary>
        /// Gets or sets whether Gallery width is determined based on the RibbonBar width. This property is in effect when
        /// Gallery is hosted directly the RibbonBar control. Default value is false.
        /// When set to true the Gallery size is changed as the RibbonBar control is resized. The initial size of the Gallery is
        /// determined by DefaultSize property. The MinimumSize property specifies the minimum size of the Gallery.
        /// Note that only single Gallery can be stretched per RibbonBar control.
        /// </summary>
        [Browsable(true), DefaultValue(false), Category("Layout"), Description("Indicates whether Gallery width is determined based on the Ribbon container size.")]
        public bool StretchGallery
        {
            get { return m_StretchGallery; }
            set
            {
                if (m_StretchGallery != value)
                {
                    m_StretchGallery = value;
                    
                    RibbonBar bar = this.ContainerControl as RibbonBar;
                    if (bar != null)
                    {
                        if (m_StretchGallery)
                        {
                            if (bar.GalleryStretch == null)
                                bar.GalleryStretch = this;
                        }
                        else
                        {
                            if (bar.GalleryStretch == this)
                                bar.GalleryStretch = null;
                        }
                    }

                    NeedRecalcSize = true;
                    OnAppearanceChanged();
                }
            }
        }

        /// <summary>
        /// Gets the collection of the items that are added to the popup gallery. The items displayed on the gallery are combined with the
        /// items from this collection and they are displayed on the gallery popup. This collection can for example have items that are
        /// customizing the choices of the commands in gallery etc.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public SubItemsCollection PopupGalleryItems
        {
            get { return m_PopupGallery.SubItems; }
        }
        /// <summary>
        /// Gets or sets the default size of the gallery. The gallery height will be always enforced so all scroll buttons can be displayed.
        /// Gallery width should allow display of both scroll buttons and the gallery content.
        /// </summary>
        [Browsable(true), Category("Layout"), Description("Indicates the default size of the gallery.")]
        public Size DefaultSize
        {
            get { return m_DefaultSize; }
            set
            {
                m_DefaultSize = value;
                this.NeedRecalcSize = true;
                this.OnAppearanceChanged();
            }
        }
        /// <summary>
        /// Gets whether DefaultSize property is serialized by Windows Forms designer based on its current value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeDefaultSize()
        {
            return (m_DefaultSize != GetDefaultSize());
        }
        /// <summary>
        /// Resets DefaultSize property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetDefaultSize()
        {
            TypeDescriptor.GetProperties(this)["DefaultSize"].SetValue(this, GetDefaultSize());
        }

        /// <summary>
        /// Gets or sets the default size of the gallery when gallery is displayed on the popup menu.
        /// </summary>
        [Browsable(true), Category("Layout"), Description("Indicates the default size of the gallery when gallery is displayed on the popup menu.")]
        public Size PopupGallerySize
        {
            get { return m_PopupGallerySize; }
            set { m_PopupGallerySize = value; }
        }
        /// <summary>
        /// Gets whether PopupGallerySize property is serialized by Windows Forms designer based on its current value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializePopupGallerySize()
        {
            return (m_PopupGallerySize != GetDefaultPopupSize());
        }
        /// <summary>
        /// Resets PopupGallerySize property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetPopupGallerySize()
        {
            TypeDescriptor.GetProperties(this)["PopupGallerySize"].SetValue(this, GetDefaultPopupSize());
        }

        /// <summary>
        /// Gets or sets whether gallery can be displayed on the popup. Default value is true.
        /// </summary>
        [Browsable(true), DefaultValue(true), Category("Gallery"), Description("Indicates whether gallery can be displayed on the popup.")]
        public bool EnableGalleryPopup
        {
            get { return m_EnableGalleryPopup; }
            set
            {
                m_EnableGalleryPopup = value;
                this.NeedRecalcSize = true;
                this.OnAppearanceChanged();
            }
        }

        /// <summary>
        /// Scrolls the gallery if necessary to ensures that item is visible.
        /// </summary>
        /// <param name="item">Reference to the items that is part of the gallery.</param>
        public void EnsureVisible(BaseItem item)
        {
            if (item == null) throw new NullReferenceException("Item must be non null value.");

            int scrollPositionY = GetScrollPosition().Y;
            Rectangle clientRectangle = GetClientRectangle();
            if (clientRectangle.IsEmpty) return;

            if (item.TopInternal + scrollPositionY < clientRectangle.Y || item.Bounds.Bottom > clientRectangle.Bottom)
            {
                int i = clientRectangle.Top - item.TopInternal + scrollPositionY;
                if (item.Bounds.Bottom > clientRectangle.Bottom)
                    i = -((item.Bounds.Bottom - clientRectangle.Y) - clientRectangle.Height) + scrollPositionY;
                if (Math.Abs(i) <= 4) i = 0;
                SetScrollPosition(i);
            }
        }

        /// <summary>
        /// Scrolls gallery down to show next line of items.
        /// </summary>
        public void ScrollDown()
        {
            SetScrollPosition(GetNextScrollLine());
        }

        /// <summary>
        /// Scrolls gallery up to show previous line of items.
        /// </summary>
        public void ScrollUp()
        {
            SetScrollPosition(GetPreviousScrollLine());
        }
        #endregion

        #region Internal Implementation
        public override BaseItem ItemAtLocation(int x, int y)
        {
            if (!this.DesignMode && (!m_PopupGalleryStyle || !m_PopupUsesStandardScrollbars))
            {
                if (m_ScrollUp.DisplayRectangle.Contains(x, y) && m_ScrollUp.Visible)
                    return m_ScrollUp;
                else if (m_ScrollDown.DisplayRectangle.Contains(x, y) && m_ScrollDown.Visible)
                    return m_ScrollDown;
                else if (m_EnableGalleryPopup && m_PopupGallery.DisplayRectangle.Contains(x, y))
                    return m_PopupGallery;
            }
            else if (!this.DesignMode && m_PopupGalleryStyle && m_PopupUsesStandardScrollbars && !SystemGallery && IsOnPopup(this))
            {
                if (m_ScrollBar != null && (m_ScrollBar.DisplayRectangle.Contains(x, y) || m_ScrollBar.IsMouseDown)) return this;
            }

            if (m_MouseDownOnScrollBar)
                return this;
            return base.ItemAtLocation(x, y);
        }

        internal ScrollBar.ScrollBarCore ScrollBarControl
        {
            get
            {
                return m_ScrollBar;
            }
        }

        void PopupScrollBar_ValueChanged(object sender, EventArgs e)
        {
            if (!_SettingScrollPosition)
                SetScrollPosition(-m_ScrollBar.Value);
        }

        private bool _SettingScrollPosition = false;
        private void SetScrollPosition(int y)
        {
            if (m_ScrollPosition.Y == y) return;

            _SettingScrollPosition = true;
            int diff = y - m_ScrollPosition.Y;
            int start = m_ScrollPosition.Y;

            m_ScrollPosition.Y = y;
            OffsetSubItems(new Point(0, diff));

            if (!m_PopupGalleryStyle || !m_PopupUsesStandardScrollbars) EnableScrollButtons(this.DisplayRectangle);
            if (IsAnimationEnabled)
                StartAnimation(start, y);
            else
                this.Refresh();
            if (m_ScrollBar != null && m_ScrollBar.Value != -y)
                m_ScrollBar.Value = -y;
            _SettingScrollPosition = false;
        }

        public override void Paint(ItemPaintArgs p)
        {
            m_ThreadUI.StartReadOperation();
            try
            {
                if (m_StateBitmap != null)
                {
                    base.PaintBackground(p);
                    Graphics g = p.Graphics;
                    Rectangle clip = GetClipRectangle();
                    Region oldClip = g.Clip;
                    g.SetClip(clip, CombineMode.Intersect);
                    
                    p.Graphics.DrawImage(m_StateBitmap, clip.X, clip.Y + m_AnimationCurrentPos);

                    if (oldClip != null)
                        g.Clip = oldClip;
                    else
                        g.ResetClip();
                    
                }
                else
                    base.Paint(p);
            }
            finally
            {
                m_ThreadUI.EndReadOperation();
            }

            //int cornerSize = 0;
            //Office2007ButtonItemPainter painter = PainterFactory.CreateButtonPainter(m_ScrollUp) as Office2007ButtonItemPainter;
            //if (painter != null)
            //{
            //    cornerSize = painter.CornerSize;
            //    painter.CornerSize = 2;
            //}

            if (m_PopupGalleryStyle && m_PopupUsesStandardScrollbars)
            {
                if (m_ScrollBar.ParentControl == null) m_ScrollBar.ParentControl = p.ContainerControl;
                m_ScrollBar.Paint(p);
            }
            else
            {
                if(m_ScrollUp.Visible)
                    m_ScrollUp.Paint(p);
                if (m_ScrollDown.Visible)
                    m_ScrollDown.Paint(p);
                if (m_EnableGalleryPopup)
                    m_PopupGallery.Paint(p);
            }

            //if (painter != null)
            //    painter.CornerSize = cornerSize;
        }

        private Point GetScrollPosition()
        {
            return m_ScrollPosition;
        }

        private Size GetLayoutSize()
        {
            if (!m_RecommendedSize.IsEmpty && m_RecommendedSize.Width >= this.MinimumSize.Width && m_RecommendedSize.Height >= this.MinimumSize.Height)
                return m_RecommendedSize;
            Size s = m_DefaultSize;
            if (this.PopupGalleryStyle && !this.SystemGallery)
            {
                if (this.MinimumSize.Width > s.Width)
                    s.Width = this.MinimumSize.Width;
                if (this.MinimumSize.Height > s.Height)
                    s.Height = this.MinimumSize.Height;
            }
            return Dpi.Size(s);
        }

        protected override System.Drawing.Rectangle GetLayoutRectangle(System.Drawing.Rectangle bounds)
        {
            Rectangle r = new Rectangle(bounds.Location, GetLayoutSize());

            if (m_PopupUsesStandardScrollbars || !m_PopupGalleryStyle)
            {
                r.Width -= Dpi.Width(m_ScrollButtonSize.Width + m_ScrollButtonContentSpacing);
                if (this.IsRightToLeft)
                    r.X += Dpi.Width(m_ScrollButtonSize.Width + m_ScrollButtonContentSpacing);
            }
            bool disposeStyle = false;
            ElementStyle style = ElementStyleDisplay.GetElementStyle(BackgroundStyle, out disposeStyle);
            r.X += ElementStyleLayout.LeftWhiteSpace(style);
            r.Y += ElementStyleLayout.TopWhiteSpace(style);
            r.Width -= ElementStyleLayout.HorizontalStyleWhiteSpace(style);
            r.Height -= ElementStyleLayout.VerticalStyleWhiteSpace(style);

            r.Offset(GetScrollPosition());

            if(disposeStyle) style.Dispose();

            return r;
        }

        protected override Rectangle LayoutItems(Rectangle bounds)
        {
            m_ViewRectangle = base.LayoutItems(bounds);
            if (m_ViewRectangle.Height < Math.Abs(m_ScrollPosition.Y)) SetScrollPosition(0);
            Size size = GetLayoutSize();
            if (this.SystemGallery && !this.EnableGalleryPopup || this.IsOnMenu)
            {
                if(size.Height > m_ViewRectangle.Height)
                    size.Height = m_ViewRectangle.Height;
            }
            if (m_IncrementalSizing && !PopupGalleryStyle)
                size.Width = m_ViewRectangle.Width + Dpi.Width(m_ScrollButtonSize.Width + m_ScrollButtonContentSpacing);
            Rectangle r = new Rectangle(bounds.Location, size);

            int minHeight = Dpi.Height(m_ScrollButtonSize.Height * 2) - 1;
            if (m_EnableGalleryPopup) minHeight += Dpi.Height(m_ScrollButtonSize.Height) - 1;
            r.Height = Math.Max(minHeight, r.Height);
            RepositionButtons(r);

            if (m_PopupGalleryStyle && m_PopupUsesStandardScrollbars)
            {
                if (m_ViewRectangle.Bottom - r.Bottom > 0)
                {
                    m_ScrollBar.Enabled = true;
                    m_ScrollBar.Maximum = m_ViewRectangle.Bottom - r.Bottom;
                    m_ScrollBar.Minimum = 0;
                    m_ScrollBar.SmallChange = GetScrollLineHeight();
                    m_ScrollBar.LargeChange = (int)(m_ScrollBar.Maximum * ((float)r.Height / (float)m_ViewRectangle.Height));
                }
                else
                    m_ScrollBar.Enabled = false;
            }
            else
            {
                EnableScrollButtons(r);
            }
            return r;
        }

        protected override Size GetEmptyDesignTimeSize()
        {
            if (m_PopupGalleryStyle && !this.SystemGallery)
            {
                Size s = this.MinimumSize;
                if(!s.IsEmpty)
                    return s;
            }

            return base.GetEmptyDesignTimeSize();
        }

        internal bool IsAtMinimumSize
        {
            get
            {
                if (m_IncrementalSizing && this.SubItems.Count>0)
                {
                    return this.WidthInternal - this.SubItems[0].WidthInternal <= this.MinimumSize.Width;
                }
                else
                {
                    return this.WidthInternal <= this.MinimumSize.Width;
                }
            }
        }

        private void EnableScrollButtons(Rectangle displayRect)
        {
            if (GetScrollPosition().Y == 0)
            {
                m_ScrollUp.Enabled = false;
            }
            else
                m_ScrollUp.Enabled = true;

            if (m_PopupGalleryStyle && !m_PopupUsesStandardScrollbars)
            {
                m_ScrollUp.Visible = m_ScrollUp.Enabled;
                m_ScrollUp.Displayed = m_ScrollUp.Enabled;
            }

            if (m_ViewRectangle.Bottom + GetScrollPosition().Y > displayRect.Bottom)
                m_ScrollDown.Enabled = true;
            else
                m_ScrollDown.Enabled = false;

            if (m_PopupGalleryStyle && !m_PopupUsesStandardScrollbars)
            {
                m_ScrollDown.Visible = m_ScrollDown.Enabled;
                m_ScrollDown.Displayed = m_ScrollDown.Enabled;
            }
        }

        protected override void OnExternalSizeChange()
        {
            if (this.PopupGalleryStyle)
                RepositionButtons(this.DisplayRectangle);
            base.OnExternalSizeChange();
        }

        private void RepositionButtons(Rectangle r)
        {
            int x = r.Right - Dpi.Width(m_ScrollButtonSize.Width);
            int y = r.Y;
            if (this.IsRightToLeft)
                x = r.X + Dpi.Width(m_ScrollButtonSize.Width);
            if (!m_ViewRectangle.IsEmpty)
            {
                if (m_ViewRectangle.Y != r.Y)
                    m_ViewRectangle.Y = r.Y;
                if (m_ViewRectangle.X != r.X)
                    m_ViewRectangle.X = r.X;
            }

            if (m_PopupGalleryStyle && m_ScrollBar != null)
            {
                bool disposeStyle = false;
                ElementStyle style = ElementStyleDisplay.GetElementStyle(BackgroundStyle, out disposeStyle);
                x -= ElementStyleLayout.RightWhiteSpace(style);
                y += ElementStyleLayout.TopWhiteSpace(style);
                r.Height -= ElementStyleLayout.VerticalStyleWhiteSpace(style);
                m_ScrollBar.DisplayRectangle = new Rectangle(x, y, Dpi.Width(m_ScrollButtonSize.Width), r.Height);

                if(disposeStyle) style.Dispose();

                return;
            }
            else if (m_PopupGalleryStyle && !m_PopupUsesStandardScrollbars)
            {
                Size buttonSize = new Size(r.Width, Dpi.Height12);
                //m_ScrollUp.Displayed = false;
                //m_ScrollUp.Visible = false;
                m_ScrollUp.RecalcSize();
                m_ScrollUp.Size = buttonSize;
                m_ScrollUp.SetDisplayRectangle(new Rectangle(r.X, r.Y,
                    buttonSize.Width, buttonSize.Height));

                //m_ScrollDown.Displayed = false;
                //m_ScrollDown.Visible = false;
                m_ScrollDown.RecalcSize();
                m_ScrollDown.Size = buttonSize;
                m_ScrollDown.SetDisplayRectangle(new Rectangle(r.X, r.Bottom - buttonSize.Height,
                    buttonSize.Width, buttonSize.Height));
                return;
            }

            Rectangle buttonRect = new Rectangle(x, y, Dpi.Width(m_ScrollButtonSize.Width), Dpi.Height(m_ScrollButtonSize.Height));
            m_ScrollUp.Displayed = true;
            m_ScrollUp.RecalcSize();
            m_ScrollUp.Size = buttonRect.Size;
            m_ScrollUp.SetDisplayRectangle(buttonRect);
            if (m_EnableGalleryPopup)
            {
                y = r.Bottom - Dpi.Height(m_ScrollButtonSize.Height);
                buttonRect = new Rectangle(x, y, Dpi.Width(m_ScrollButtonSize.Width), Dpi.Height(m_ScrollButtonSize.Height));
                m_PopupGallery.Displayed = true;
                m_PopupGallery.RecalcSize();
                m_PopupGallery.Size = buttonRect.Size;
                m_PopupGallery.SetDisplayRectangle(buttonRect);
                buttonRect.Offset(0, -(Dpi.Height(m_ScrollButtonSize.Height) - 1));
            }
            else
            {
                m_PopupGallery.Displayed = false;
                y = r.Bottom - Dpi.Height(m_ScrollButtonSize.Height);
                buttonRect = new Rectangle(x, y, Dpi.Width(m_ScrollButtonSize.Width), Dpi.Height(m_ScrollButtonSize.Height));
            }

            m_ScrollDown.Displayed = true;
            m_ScrollDown.RecalcSize();
            m_ScrollDown.Size = buttonRect.Size;
            m_ScrollDown.SetDisplayRectangle(buttonRect);
        }

        // <summary>
        /// Called after LeftInternal property has changed
        /// </summary>
        protected override void OnLeftLocationChanged(int oldValue)
        {
            base.OnLeftLocationChanged(oldValue);
            RepositionButtons(this.DisplayRectangle);
        }

        public override Rectangle Bounds
        {
            get
            {
                return base.Bounds;
            }
            set
            {
                base.Bounds = value;
                RepositionButtons(this.DisplayRectangle);
            }
        }

        protected override void OnTopLocationChanged(int oldValue)
        {
            base.OnTopLocationChanged(oldValue);
            RepositionButtons(this.DisplayRectangle);
        }

        protected override void OnStyleChanged()
        {
            m_ScrollUp.Style = this.Style;
            m_ScrollDown.Style = this.Style;
            m_PopupGallery.Style = this.Style;
            if (BarFunctions.IsOffice2010Style(this.Style))
            {
                m_ScrollUp.Shape = new RoundRectangleShapeDescriptor();
                m_ScrollDown.Shape = new RoundRectangleShapeDescriptor();
                m_PopupGallery.Shape = new RoundRectangleShapeDescriptor();
            }
            else
            {
                m_ScrollUp.Shape = null;
                m_ScrollDown.Shape = null;
                m_PopupGallery.Shape = null;
            }
            base.OnStyleChanged();
        }

        private int GetScrollLineHeight()
        {
            int itemY = this.DisplayRectangle.Bottom + GetScrollPosition().Y;
            foreach (BaseItem item in this.SubItems)
            {
                if (!item.Visible) continue;

                if (item.TopInternal > itemY)
                    return item.HeightInternal;
            }
            return 24;
        }

        private int GetNextScrollLine()
        {
            bool firstVisibleFound = false;
            int itemY = 0;
            foreach (BaseItem item in this.SubItems)
            {
                if (!item.Visible) continue;

                if (firstVisibleFound && item.TopInternal > itemY)
                    return GetScrollForItem(item);
                if (!firstVisibleFound && item.TopInternal >= this.TopInternal)
                {
                    firstVisibleFound = true;
                    itemY = item.TopInternal;
                }
            }

            return GetScrollPosition().Y;
        }

        private int GetPreviousScrollLine()
        {
            if (GetScrollPosition().Y == 0)
                return 0;

            int c = this.SubItems.Count -1;
            for (int i = c; i >= 0; i--)
            {
                BaseItem item = this.SubItems[i];
                if (!item.Visible) continue;
                if (item.TopInternal < this.TopInternal)
                    return GetScrollForItem(item);
            }

            return 0;
        }

        private int GetScrollForItem(BaseItem item)
        {
            int i = this.DisplayRectangle.Top - item.TopInternal + GetScrollPosition().Y;
            if (Math.Abs(i) <= 4) i = 0;
            return i;
        }

        /// <summary>
        /// Gets or sets a value indicating whether the item is expanded or not. For Popup items this would indicate whether the item is popped up or not.
        /// </summary>
        [System.ComponentModel.Browsable(false), System.ComponentModel.DefaultValue(false), System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public override bool Expanded
        {
            get
            {
                return m_Expanded;
            }
            set
            {
                base.Expanded = value;
                if (!value && m_PopupGallery.Expanded)
                    m_PopupGallery.Expanded = false;
            }
        }

        /// <summary>
        /// Gets whether the Gallery popup is open.
        /// </summary>
        [Browsable(false)]
        public bool IsGalleryPopupOpen
        {
            get
            {
                return m_PopupGallery.Expanded;
            }
        }

        /// <summary>
        /// Opens the Gallery popup menu.
        /// </summary>
        public void PopupGallery()
        {
            if (m_PopupGallery.Expanded)
            {
                m_PopupGallery.Expanded = false;
            }
            else
            {
                if (!this.DesignMode)
                {
                    System.Windows.Forms.Control ctrl = this.ContainerControl as System.Windows.Forms.Control;
                    Point p = ctrl.PointToScreen(this.DisplayRectangle.Location);
                    GalleryContainer c = null;
                    if (m_Groups.Count > 0)
                    {
                        c = new GalleryContainer();
                        c.DefaultSize = this.DefaultSize;
                        c.StretchGallery = this.StretchGallery;
                        c.MultiLine = false;
                        c.LayoutOrientation = eOrientation.Vertical;

                        foreach (BaseItem item in this.PopupGalleryItems)
                            c.PopupGalleryItems.Add(item.Copy());

                        ArrangePopupGroups(c);
                    }
                    else
                        c = this.Copy() as GalleryContainer;
                    c.EnableGalleryPopup = false;
                    c.SystemGallery = true;
                    c.IncrementalSizing = false;
                    c.PopupUsesStandardScrollbars = m_PopupUsesStandardScrollbars;
                    if (this.PopupGallerySize.IsEmpty)
                        c.DefaultSize = GetPopupGallerySize(p);
                    else
                        c.DefaultSize = this.PopupGallerySize;
                    c.BackgroundStyle.Reset();
                    c.PopupGalleryStyle = true;
                    m_PopupGallery.SubItems.Insert(0, c);
                    m_PopupGallery.PopupMenu(p);
                }
                else
                    m_PopupGallery.Expanded = true;
            }
        }

        protected internal override void OnContainerChanged(object objOldContainer)
        {
            if (!this.SystemGallery)
            {
                if (BaseItem.IsOnPopup(this))
                {
                    SetScrollPosition(0);
                    this.PopupGalleryStyle = true;
                }
            }
            base.OnContainerChanged(objOldContainer);
        }

        private void ArrangePopupGroups(GalleryContainer gc)
        {
            ArrayList groupList = GetSortedGroupList();
            foreach(GalleryGroup g in groupList)
            {
                if (g.Items.Count == 0)
                    continue;

                LabelItem label = CreateLabelForGroup(g);
                gc.SubItems.Add(label);
                ItemContainer cont = CreateContainerFormGroup(g);
                gc.SubItems.Add(cont);
            }
        }

        private ItemContainer CreateContainerFormGroup(GalleryGroup g)
        {
            ItemContainer c = new ItemContainer();
            c.LayoutOrientation = eOrientation.Horizontal;
            c.MultiLine = true;
            c.Name = "container_" + g.Name;

            foreach (BaseItem item in g.Items)
            {
                c.SubItems.Add(item.Copy());
            }

            return c;
        }

        private LabelItem CreateLabelForGroup(GalleryGroup g)
        {
            LabelItem l = new LabelItem("label_" + g.Name, g.Text);
            if (Rendering.GlobalManager.Renderer is Rendering.Office2007Renderer)
            {
                Rendering.Office2007ColorTable ct = ((Rendering.Office2007Renderer)Rendering.GlobalManager.Renderer).ColorTable;
                l.BackColor = ct.Gallery.GroupLabelBackground;
                l.ForeColor = ct.Gallery.GroupLabelText;
                l.SingleLineColor= ct.Gallery.GroupLabelBorder;
                l.BorderType = eBorderType.SingleLine;
                l.BorderSide = eBorderSide.Bottom;
                l.PaddingTop = 1;
                l.PaddingLeft = 10;
                l.PaddingBottom = 1;
            }
            return l;
        }

        private ArrayList GetSortedGroupList()
        {
            ArrayList groups = new ArrayList(m_Groups.Count);
            foreach(GalleryGroup g in m_Groups)
                groups.Add(g);
            groups.Sort(new GroupDisplayOrderComparer());

            return groups;
        }

        private class GroupDisplayOrderComparer : IComparer
        {
            // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
            int IComparer.Compare(object x, object y)
            {
                if (x is GalleryGroup && y is GalleryGroup)
                {
                    return ((GalleryGroup)x).DisplayOrder - ((GalleryGroup)y).DisplayOrder;
                }
                else
                    return ((new CaseInsensitiveComparer()).Compare(x, y));
            }
        }

        protected override InsertPosition GetContainerInsertPosition(Point pScreen, BaseItem dragItem)
        {
            InsertPosition pos = DesignTimeProviderContainer.GetInsertPosition(this, pScreen, dragItem);
            if (pos == null && m_PopupGallery.Expanded)
                pos = m_PopupGallery.GetInsertPosition(pScreen, dragItem);
            return pos;
        }

        protected override IContentLayout GetContentLayout()
        {
            SerialContentLayoutManager lm = base.GetContentLayout() as SerialContentLayoutManager;
            if (lm != null)
                lm.HorizontalFitContainerHeight = false;

            return lm;
        }

        /// <summary>
        /// Gets or sets the Key Tips access key or keys for the item when on Ribbon Control or Ribbon Bar. Use KeyTips property
        /// when you want to assign the one or more letters to be used to access an item. For example assigning the FN to KeyTips property
        /// will require the user to press F then N keys to select an item. Pressing the F letter will show only keytips for the items that start with letter F.
        /// </summary>
        [Browsable(true), Category("Appearance"), DefaultValue(""), Description("Indicates the Key Tips access key or keys for the item when on Ribbon Control or Ribbon Bar.")]
        public override string KeyTips
        {
            get { return base.KeyTips; }
            set { base.KeyTips = value; }
        }
        #endregion

        #region Scroll Animation
        private Bitmap m_StateBitmap = null;
        private int m_AnimationEndPos = 0;
        private int m_AnimationCurrentPos = 0;
        private int m_AnimationStep = 0;
        private void StartAnimation(int start, int end)
        {
            m_AnimationEndPos = end;
            m_AnimationCurrentPos = start;
            m_AnimationStep = (int)Math.Max(8, Math.Abs(end - start) / 3);
            //Console.WriteLine("Start ={0}  End = {1}   Step = {2}", start, end, m_AnimationStep);
            if (end < start) m_AnimationStep *= -1;

            m_ThreadUI.Start();

        }

        private void RecordStartState(object sender, EventArgs e)
        {
            m_StateBitmap = new Bitmap(m_ViewRectangle.Width, m_ViewRectangle.Height, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
            Graphics g1 = Graphics.FromImage(m_StateBitmap);
            BufferedBitmap bb = new BufferedBitmap(g1, new Rectangle(0, 0, m_ViewRectangle.Width, m_ViewRectangle.Height));
            Graphics g = bb.Graphics;
            Color transparentColor = Color.Empty;
            try
            {
                bool disposeStyle = false;
                ElementStyle style = ElementStyleDisplay.GetElementStyle(this.BackgroundStyle, out disposeStyle);
                if (!style.BackColor.IsEmpty)
                    transparentColor = style.BackColor;
                else if (style.BackColorBlend.Count > 0 && !style.BackColorBlend[0].Color.IsEmpty)
                    transparentColor = style.BackColorBlend[0].Color;
                else
                    transparentColor = Color.WhiteSmoke;

                if (!transparentColor.IsEmpty)
                {
                    using (SolidBrush brush = new SolidBrush(transparentColor))
                        g.FillRectangle(brush, 0, 0, m_StateBitmap.Width, m_StateBitmap.Height);
                }
                System.Windows.Forms.Control cc = this.ContainerControl as System.Windows.Forms.Control;
                bool antiAlias = false;
                ItemPaintArgs pa = null;
                if (cc is ItemControl)
                {
                    antiAlias = ((ItemControl)cc).AntiAlias;
                    pa = ((ItemControl)cc).GetItemPaintArgs(g);
                }
                else if (cc is Bar)
                {
                    antiAlias = ((Bar)cc).AntiAlias;
                    pa = ((Bar)cc).GetItemPaintArgs(g);
                }
                else if (cc is ButtonX)
                {
                    antiAlias = ((ButtonX)cc).AntiAlias;
                    pa = ((ButtonX)cc).GetItemPaintArgs(g);
                }
                else if (cc is MenuPanel)
                {
                    antiAlias = ((MenuPanel)cc).AntiAlias;
                    pa = ((MenuPanel)cc).GetItemPaintArgs(g);
                }

                Rectangle clip = GetClipRectangle();
                System.Drawing.Drawing2D.Matrix myMatrix = new System.Drawing.Drawing2D.Matrix();
                myMatrix.Translate( -(clip.X + +m_ScrollPosition.X),
                                    -(clip.Y + m_ScrollPosition.Y), 
                                    System.Drawing.Drawing2D.MatrixOrder.Append);
                g.Transform = myMatrix;

                if (antiAlias)
                {
                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                    g.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
                }

                if (pa == null)
                {
                    m_StateBitmap.Dispose();
                    m_StateBitmap = null;
                }

                // Do not paint scrollbars just content
                ItemDisplay display = GetItemDisplay();
                display.Paint(this, pa);
                bb.Render(g1);

                if(disposeStyle) style.Dispose();
            }
            finally
            {
                g = null;
                bb.Dispose();
                g1.Dispose();
            }
            if (!transparentColor.IsEmpty)
                m_StateBitmap.MakeTransparent(transparentColor);
        }

        private void CleanupState(object sender, EventArgs e)
        {
            if (m_StateBitmap != null)
            {
                m_StateBitmap.Dispose();
                m_StateBitmap = null;
            }
        }

        private void UpdateThreadedUI(object sender, EventArgs e)
        {
            m_AnimationCurrentPos += m_AnimationStep;

            if (m_AnimationCurrentPos <= m_AnimationEndPos && m_AnimationEndPos < 0 && m_AnimationStep < 0 ||
                m_AnimationCurrentPos >= m_AnimationEndPos && m_AnimationEndPos >= 0 && m_AnimationStep > 0 || 
                m_AnimationCurrentPos >= m_AnimationEndPos && m_AnimationEndPos < 0 && m_AnimationStep > 0 ||
                m_AnimationCurrentPos <= m_AnimationEndPos && m_AnimationEndPos >= 0 && m_AnimationStep < 0)
                m_ThreadUI.Stop();

            System.Windows.Forms.Control cc = this.ContainerControl as System.Windows.Forms.Control;
            if (cc != null)
                cc.Invalidate(this.DisplayRectangle);
        }

        private bool IsAnimationEnabled
        {
            get
            {
                if (this.DesignMode || !m_ScrollAnimation || !this.Displayed || TextDrawing.UseTextRenderer || NativeFunctions.IsTerminalSession())
                    return false;
                //System.Windows.Forms.Control cc = this.ContainerControl as System.Windows.Forms.Control;
                //if (cc != null)
                //{
                //    if (cc is ItemControl)
                //        return ((ItemControl)cc).IsFadeEnabled;
                //    else if (cc is Bar)
                //        return ((Bar)cc).IsFadeEnabled;
                //    else if (cc is ButtonX)
                //        return ((ButtonX)cc).IsFadeEnabled;
                //}
                return m_ScrollAnimation;
            }
        }

        protected override void OnDisplayedChanged()
        {
            if(!this.Displayed && !this.SystemGallery && this.PopupGalleryStyle)
                SetScrollPosition(0);
            base.OnDisplayedChanged();
        }

        protected internal override void OnVisibleChanged(bool newValue)
        {
            base.OnVisibleChanged(newValue);
            if (!newValue)
            {
                m_ThreadUI.Stop();
            }
        }

        /// <summary>
        /// Gets or sets whether scroll animation is enabled. Default value is true.
        /// Scroll animation will be disabled if gallery is running under Remote Windows Terminal session or fade animation effect is disabled on the
        /// container control.
        /// </summary>
        [Browsable(true), DefaultValue(true), Category("Animation"), Description("Indicates whether scroll animation is enabled.")]
        public bool ScrollAnimation
        {
            get { return m_ScrollAnimation; }
            set { m_ScrollAnimation = value; }
        }

        /// <summary>
        /// Called on each item when ScaleControl method of parent control is called and gives opportunity to item to adjust its displayed based on current scaling.
        /// </summary>
        /// <param name="factor">Scale factor.</param>
        protected override void ScaleItem(SizeF factor)
        {
            base.ScaleItem(factor);
            if (m_PopupGallery == null) return;
            m_PopupGallery.NotifyScaleItem(factor);
        }
        #endregion

        #region IExtenderProvider Implementation, GalleryGroup property extender
        /// <summary>
        /// Returns whether Gallery can extend the object.
        /// </summary>
        /// <param name="extendee">Object to test extensibility for.</param>
        /// <returns>Returns true if object can be extended otherwise false.</returns>
        public bool CanExtend(object extendee)
        {
            BaseItem item = extendee as BaseItem;
            if (item == null) return false;
            return this.SubItems.Contains(item);
        }

        /// <summary>
        /// Gets the GalleryGroup item is assigned to.
        /// </summary>
        /// <param name="item">Reference to item.</param>
        /// <returns>An instance of GalleryGroup object or null if item is not assigned to the group</returns>
        [Editor("DevComponents.DotNetBar.Design.GalleryGroupTypeEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)), DefaultValue(null)]
        public GalleryGroup GetGalleryGroup(BaseItem item)
        {
            if (item == null) return null;
            return GetItemGalleryGroup(item);
        }
        /// <summary>
        /// Assigns the item to the gallery group.
        /// </summary>
        /// <param name="item">Item to assign.</param>
        /// <param name="group">Group to assign item to. Can be null to remove item assignment.</param>
        public void SetGalleryGroup(BaseItem item, GalleryGroup group)
        {
            if (item == null)
                throw new ArgumentNullException("item argument cannot be null.");

            if (group == null)
            {
                GalleryGroup g = GetItemGalleryGroup(item);
                if (g != null)
                    g.Items.Remove(item);
            }
            else
            {
                GalleryGroup g = GetItemGalleryGroup(item);
                if (g != null)
                    g.Items.Remove(item);
                group.Items.Add(item);
            }
        }

        private GalleryGroup GetItemGalleryGroup(BaseItem item)
        {
            foreach (GalleryGroup g in m_Groups)
            {
                if (g.Items.Contains(item))
                    return g;
            }
            return null;
        }

        /// <summary>
        /// Gets the collection of GalleryGroup objects associated with this gallery. Groups are assigned optionally to one or more items
        /// that are part of the GalleryContainer. Groups are used to visually group the items when gallery is displayed on the popup.
        /// </summary>
        [Editor("DevComponents.DotNetBar.Design.GalleryGroupCollectionEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Category("Groups"), Browsable(false), Description("Gets the collection of GalleryGroup objects associated with this gallery.")]
        public GalleryGroupCollection GalleryGroups
        {
            get { return m_Groups; }
        }
        #endregion
    }
}