using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms;

namespace DevComponents.DotNetBar
{
	#region Event Delegates
	/// <summary>
	/// Delegate for OptionGroupChanging event.
	/// </summary>
	public delegate void PanelChangingEventHandler(object sender,  PanelChangingEventArgs e);

	/// <summary>
	/// Delegate for PanelPopup events.
	/// </summary>
	public delegate void PanelPopupEventHandler(object sender,  PanelPopupEventArgs e);
	#endregion

	/// <summary>
	/// Represents Outlook 2003 style navigation pane control.
	/// </summary>
    [ToolboxItem(true), Designer("DevComponents.DotNetBar.Design.NavigationPaneDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf")]
	public class NavigationPane : System.Windows.Forms.UserControl
	{
		private DevComponents.DotNetBar.PanelExTitle panelTitle;
		private DevComponents.DotNetBar.NavigationBar navBar;

		/// <summary> 
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.Container components = null;
		private int m_NavigationBarHeight=0;
        private bool m_CanCollapse = false;
        private bool m_Expanded = true;
        private bool m_ExpandedDelayed = true;
        private Image m_DefaultCollapseImage = null;
        private Image m_DefaultExpandImage = null;
        private Image m_DefaultCollapseImageMouseOver = null;
        private Image m_DefaultExpandImageMouseOver = null;

        private Image m_TitleImageCollapse = null;
        private Image m_TitleImageExpand = null;
        private Image m_TitleImageCollapseMouseOver = null;
        private Image m_TitleImageExpandMouseOver = null;
        private int m_ExpandedSize = 0;
        private int m_CollapsedSize = 0;
        private PanelEx m_PanePopupPanel = null;
        private int m_AnimationTime = 100;
        private bool m_PopupPaneVisible = false;
        private PanelEx m_PopupPanelContainer = null;
        private bool m_LayoutSuspended = false;

		#region Events
		/// <summary>
		/// Occurs when Item is clicked.
		/// </summary>
		[System.ComponentModel.Description("Occurs when Item is clicked."),Category("Navigation Pane Events")]
		public event EventHandler ItemClick;
        /// <summary>
        /// Occurs when currently selected panel is about to change.
        /// </summary>
		[System.ComponentModel.Description("Occurs when Item is clicked."),Category("Navigation Pane Events")]
		public event PanelChangingEventHandler PanelChanging;

        /// <summary>
        /// Occurs when control is looking for translated text for one of the internal text that are
        /// displayed on menus, toolbars and customize forms. You need to set Handled=true if you want
        /// your custom text to be used instead of the built-in system value.
        /// </summary>
        public event DotNetBarManager.LocalizeStringEventHandler LocalizeString;

		/// <summary>
		/// Occurs before panel is displayed on popup when control is collapsed. You can use this event to modify default
		/// size of the popup panel or cancel the popup of the panel.
		/// </summary>
		public event PanelPopupEventHandler BeforePanelPopup;

        /// <summary>
        /// Occurs after panel is displayed on popup.
        /// </summary>
        public event EventHandler AfterPanelPopup;

        /// <summary>
        /// Occurs after panel displayed on popup is closed.
        /// </summary>
        public event EventHandler PanelPopupClosed;

		/// <summary>
		/// Occurs before Expanded property is changed. You can cancel change of this property by setting Cancel=true on the event arguments.
		/// </summary>
		public event ExpandChangeEventHandler ExpandedChanging;
		/// <summary>
		/// Occurs after Expanded property has changed. You can handle ExpandedChanging event and have opportunity to cancel the change.
		/// </summary>
		public event ExpandChangeEventHandler ExpandedChanged;
        /// <summary>
        /// Occurs after Options dialog which is used to customize control's content has closed by user using OK button.
        /// </summary>
        public event EventHandler OptionsDialogClosed;
		#endregion

		public NavigationPane()
		{
			// This call is required by the Windows.Forms Form Designer.
			InitializeComponent();

			this.SetStyle(ControlStyles.Opaque,true);
			this.SetStyle(DisplayHelp.DoubleBufferFlag,true);
			this.SetStyle(ControlStyles.AllPaintingInWmPaint,true);

			navBar.ItemAdded+=new EventHandler(NavBarItemAdded);
			navBar.ItemRemoved+=new BarBaseControl.ItemRemovedEventHandler(NavBarItemRemoved);
            navBar.ApplicationMouseDown += new HandlerMessageEventHandler(ApplicationMouseDown);
            navBar.LocalizeString += new DotNetBarManager.LocalizeStringEventHandler(navBar_LocalizeString);
            navBar.OptionsDialogClosed += new EventHandler(NavBarOptionsDialogClosed);
			navBar.SplitterVisible=true;
			m_NavigationBarHeight=navBar.Height;
            panelTitle.ExpandedClick += new EventHandler(panelEx1_ExpandedClick);
            panelTitle.ExpandChangeButton.ImagePaddingHorizontal = 2;
            panelTitle.ExpandChangeButton.ImagePaddingVertical = 2;

            StyleManager.Register(this);
		}

        void NavBarOptionsDialogClosed(object sender, EventArgs e)
        {
            OnOptionsDialogClosed(e);
        }

        void navBar_LocalizeString(object sender, LocalizeEventArgs e)
        {
            if (LocalizeString != null)
                LocalizeString(this, e);
        }

        protected virtual void OnOptionsDialogClosed(EventArgs e)
        {
            EventHandler handler = OptionsDialogClosed;
            if (handler != null) handler(this, e);
        }

        /// <summary> 
		/// Clean up any resources being used.
		/// </summary>
		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
                if (m_DefaultCollapseImage != null)
                    m_DefaultCollapseImage.Dispose();
                if (m_DefaultExpandImage != null)
                    m_DefaultExpandImage.Dispose();
				if(components != null)
				{
					components.Dispose();
				}
			}
            StyleManager.Unregister(this);
			base.Dispose( disposing );
		}
		
		protected override void OnPaint(PaintEventArgs e)
		{
			base.OnPaint(e);

            if (navBar.ItemsContainer.EffectiveStyle == eDotNetBarStyle.Office2010)
            {
                Rendering.BaseRenderer renderer = navBar.GetRenderer();
                if(renderer!=null)
                    renderer.DrawNavPaneButtonBackground(new NavPaneRenderEventArgs(e.Graphics, this.ClientRectangle));
            }
            else
            {
                using (SolidBrush brush = new SolidBrush(this.NavigationBar.GetColorScheme().BarBackground))
                    e.Graphics.FillRectangle(brush, this.ClientRectangle);
                using (Pen pen = new Pen(this.NavigationBar.GetColorScheme().PanelBorder, 1))
                    e.Graphics.DrawRectangle(pen, new Rectangle(0, 0, this.Width - 1, this.Height - 1));
            }
		}
        [EditorBrowsable(EditorBrowsableState.Never)]
		public void SetDesignMode()
		{
			navBar.SetDesignMode(this.DesignMode);
		}

        /// <summary>
        /// Returns the width of the expanded control if control is currently collapsed.
        /// </summary>
        [Browsable(false)]
        public int ExpandedSize
        {
            get { return m_ExpandedSize; }
        }

		/// <summary>
		/// Returns collection containing buttons on navigation bar.
		/// </summary>
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
		public SubItemsCollection Items
		{
			get
			{
				return navBar.Items;
			}
		}

		/// <summary>
		/// Applies any layout changes and repaint the control.
		/// </summary>
		public virtual void RecalcLayout()
		{
			navBar.RecalcLayout();
		}

		private void NavBarItemAdded(object sender, EventArgs e)
		{
			ButtonItem item=sender as ButtonItem;
            if (item != null && !item.IsOnCustomizeMenu)
            {
                item.CheckedChanged += new EventHandler(ItemCheckedChanged);
                item.TextChanged += new EventHandler(ItemTextChanged);
                item.VisibleChanged += new EventHandler(ItemVisibleChanged);

                if (item.Checked)
                {
                    item.SetChecked(false);
                    item.Checked = true;
                }
            }
		}

        void ItemVisibleChanged(object sender, EventArgs e)
        {
            ButtonItem item = sender as ButtonItem;
            if (item == null || item.IsOnCustomizeMenu)
                return;
            if (item.Checked && !item.Visible)
            {
                foreach (BaseItem childItem in this.Items)
                {
                    ButtonItem button = childItem as ButtonItem;
                    if (button == null || !button.Visible)
                        continue;
                    button.Checked = true;
                    break;
                }
            }
        }

		private void NavBarItemRemoved(object sender, ItemRemovedEventArgs e)
		{
			ButtonItem item=sender as ButtonItem;
			if(item!=null)
			{
				try
				{
					item.CheckedChanged-=new EventHandler(ItemCheckedChanged);
                    item.TextChanged -= new EventHandler(ItemTextChanged);
                    item.VisibleChanged -= new EventHandler(ItemVisibleChanged);
				}
				catch{}
			}
		}

		private void ItemCheckedChanged(object sender, EventArgs e)
		{
			ButtonItem item=sender as ButtonItem;
			if(item==null || item.IsOnCustomizeMenu)
				return;
			foreach(Control c in this.Controls)
			{
				if(c is NavigationPanePanel)
				{
					NavigationPanePanel panel=c as NavigationPanePanel;
					if(panel.ParentItem==item)
					{
						if(item.Checked)
						{
                            if (m_Expanded)
                            {
                                if (!this.DesignMode)
                                    panel.Visible = true;
                                panel.BringToFront();
                            }
							panelTitle.Text=item.Text;
                            if (m_PanePopupPanel != null)
                                m_PanePopupPanel.Text = panelTitle.Text;
						}
						else
						{
                            if (m_Expanded)
                            {
                                if (!this.DesignMode)
                                    panel.Visible = false;
                                else
                                    panel.SendToBack();
                            }
						}
						break;
					}
				}
			}
		}

		private void ItemTextChanged(object sender, EventArgs e)
		{
			ButtonItem item=sender as ButtonItem;
			if(item==null)
				return;
            if (item.Checked)
            {
                panelTitle.Text = item.Text;
                if (m_PanePopupPanel != null)
                    m_PanePopupPanel.Text = item.Text;
            }
		}

		protected override void OnControlAdded(ControlEventArgs e)
		{
			base.OnControlAdded(e);

			if(this.DesignMode)
				return;
			NavigationPanePanel panel=e.Control as NavigationPanePanel;
			if(panel==null)
				return;

			if(panel.ParentItem!=null && m_Expanded)
			{
				if(this.Items.Contains(panel.ParentItem) && panel.ParentItem is ButtonItem)
				{
					panel.Visible=((ButtonItem)panel.ParentItem).Checked;
					if(panel.Visible)
						panel.BringToFront();
				}
				else
					panel.Visible=false;
			}
			else
				panel.Visible=false;
		}

        protected override void OnSystemColorsChanged(EventArgs e)
        {
            base.OnSystemColorsChanged(e);
            Application.DoEvents();
            if (m_CanCollapse)
            {
                UpdateExpandCollapseImages();
                UpdateExpandButton();
            }
        }

		/// <summary>
		/// Returns Panel associated with button on navigation bar or null if panel cannot be found.
		/// </summary>
		/// <param name="item">Button on navigation bar.</param>
		/// <returns></returns>
		public NavigationPanePanel GetPanel(ButtonItem item)
		{
			if(item==null)
				return null;
			foreach(Control c in this.Controls)
			{
				NavigationPanePanel panel=c as NavigationPanePanel;
				if(panel!=null)
				{
					if(panel.ParentItem==item)
						return panel;
				}
			}
			return null;
		}

		/// <summary>
		/// Gets or sets the height of the navigation bar part of the navigation pane control.
		/// Navigation Bar height is automatically calculated based on the content.
		/// Setting this property suggests desired height of the navigation bar but the actual height will be
        /// calculated to ensure that complete buttons are visible so suggested and actual height might differ.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Layout"),DefaultValue(32)]
		public int NavigationBarHeight
		{
			get
			{
                if (!this.DesignMode && navBar != null && navBar.Items.Count > 0)
                    return navBar.Height;

				return m_NavigationBarHeight;
			}
			set
			{
				m_NavigationBarHeight=value;
				navBar.Height=m_NavigationBarHeight;
			}
		}

		private void OnNavBarResize(object sender, EventArgs e)
		{
			if(this.DesignMode)
				m_NavigationBarHeight=navBar.Height;
		}

        protected override void OnLayout(LayoutEventArgs e)
        {
            base.OnLayout(e);
            UpdatePanePopupPanelSize();
        }

        /// <summary>
        /// Suspends normal layout logic.
        /// </summary>
        public new void SuspendLayout()
        {
            m_LayoutSuspended = true;
            base.SuspendLayout();
        }

		/// <summary>
		/// Resumes normal layout logic. Optionally forces an immediate layout of pending layout requests.
		/// </summary>
		public new void ResumeLayout(bool performLayout)
		{
            m_LayoutSuspended = false;
			navBar.Height=m_NavigationBarHeight;
			navBar.SendToBack();
			base.ResumeLayout(true);
            this.Expanded = m_ExpandedDelayed;
		}

		/// <summary>
		/// Returns reference to internal NavigationBar control.
		/// </summary>
		[Browsable(false),DevCoBrowsable(false)]
		public NavigationBar NavigationBar
		{
			get
			{
				return navBar;
			}
		}

		/// <summary>
		/// Gets or sets size of the image that will be use to resize images to when button button is on the bottom summary line of navigation bar and AutoSizeButtonImage=true.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Appearance"),Description("Indicates size of the image that will be use to resize images to when button button is on the bottom summary line of navigation bar and AutoSizeButtonImage=true.")]
		public Size ImageSizeSummaryLine
		{
			get {return navBar.ImageSizeSummaryLine;}
			set {navBar.ImageSizeSummaryLine=value;}
		}
		[EditorBrowsable(EditorBrowsableState.Never)]
		public bool ShouldSerializeImageSizeSummaryLine()
		{
			return navBar.ShouldSerializeImageSizeSummaryLine();
		}

		/// <summary>
		/// Gets or sets whether Configure Buttons button is visible.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Behavior"),Description("Indicates Configure Buttons button is visible."),DefaultValue(true)]
		public bool ConfigureItemVisible
		{
			get {return navBar.ConfigureItemVisible;}
			set {navBar.ConfigureItemVisible=value;}
		}

		/// <summary>
		/// Gets or sets whether Show More Buttons and Show Fewer Buttons menu items are visible on Configure buttons menu.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Behavior"),Description("Indicates whether Show More Buttons and Show Fewer Buttons menu items are visible on Configure buttons menu."),System.ComponentModel.DefaultValue(true)]
		public bool ConfigureShowHideVisible
		{
			get {return navBar.ConfigureShowHideVisible;}
			set	{navBar.ConfigureShowHideVisible=value;}
		}

		/// <summary>
		/// Gets or sets whether Navigation Pane Options menu item is visible on Configure buttons menu.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Behavior"),Description("Gets or sets whether Navigation Pane Options menu item is visible on Configure buttons menu."),System.ComponentModel.DefaultValue(true)]
		public bool ConfigureNavOptionsVisible
		{
			get {return navBar.ConfigureNavOptionsVisible;}
			set	{navBar.ConfigureNavOptionsVisible=value;}
		}

		/// <summary>
		/// Gets or sets whether Navigation Pane Add/Remove Buttons menu item is visible on Configure buttons menu.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Behavior"),Description("Indicates whether Navigation Pane Add/Remove Buttons menu item is visible on Configure buttons menu."),System.ComponentModel.DefaultValue(true)]
		public bool ConfigureAddRemoveVisible
		{
			get {return navBar.ConfigureAddRemoveVisible;}
			set {navBar.ConfigureAddRemoveVisible=value;}
		}

		/// <summary>
		/// Returns reference to currently checked button.
		/// </summary>
		public ButtonItem CheckedButton
		{
			get {return navBar.CheckedButton;}
		}

		/// <summary>
		/// Returns reference to currently selected panel. Panels are automatically switched when buttons are checked.
		/// </summary>
		public NavigationPanePanel SelectedPanel
		{
			get {return this.GetPanel(this.CheckedButton);}
		}

		/// <summary>
		/// Increases the size of the navigation bar if possible by showing more buttons on the top.
		/// </summary>
		public void ShowMoreButtons()
		{
			navBar.ShowMoreButtons();
		}

		/// <summary>
		/// Reduces the size of the navigation bar if possible by showing fewer buttons on the top.
		/// </summary>
		public void ShowFewerButtons()
		{
			navBar.ShowFewerButtons();
		}

		/// <summary>
		/// ImageList for images used on Items.
		/// </summary>
		[System.ComponentModel.Browsable(true),System.ComponentModel.Category("Data"),DefaultValue(null),System.ComponentModel.Description("ImageList for images used on Items.")]
		public System.Windows.Forms.ImageList Images
		{
			get
			{
				return navBar.Images;
			}
			set
			{
				navBar.Images=value;
			}
		}

		/// <summary>
		/// Returns reference to the PanelEx that is used to display title.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),DesignerSerializationVisibility(DesignerSerializationVisibility.Content),Category("Appearance"),Description("PanelEx control that is used to display title.")]
		public PanelEx TitlePanel
		{
			get {return panelTitle;}
		}

		/// <summary>
		/// Gets or sets the padding in pixels at the top portion of the item. Height of each item will be increased by padding amount.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Layout"),Description("Indicates the padding in pixels at the top portion of the item."),DefaultValue(4)]
		public int ItemPaddingTop
		{
			get {return navBar.ItemPaddingTop;}
			set 
			{
				navBar.ItemPaddingTop=value;
				if(this.DesignMode)
					this.RecalcLayout();
			}
		}

		/// <summary>
		/// Gets or sets the padding in pixels for bottom portion of the item. Height of each item will be increased by padding amount.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Layout"),Description("Indicates the padding in pixels at the bottom of the item."),DefaultValue(4)]
		public int ItemPaddingBottom
		{
			get {return navBar.ItemPaddingBottom;}
			set 
			{
				navBar.ItemPaddingBottom=value;
				if(this.DesignMode)
					this.RecalcLayout();
			}
		}

		/// <summary>
		/// Gets or sets whether images are automatically resized to size specified in ImageSizeSummaryLine when button is on the bottom summary line of navigation bar.
		/// </summary>
		[Browsable(true),DevCoBrowsable(true),Category("Appearance"),Description("Indicates whether images are automatically resized to size specified in ImageSizeSummaryLine when button is on the bottom summary line of navigation bar."),DefaultValue(true)]
		public bool AutoSizeButtonImage
		{
			get {return navBar.AutoSizeButtonImage;}
			set {navBar.AutoSizeButtonImage=value;}
		}

		/// <summary>
		/// Saves current visual layout of navigation bar control to XML based file.
		/// </summary>
		/// <param name="fileName">File name to save layout to.</param>
		public void SaveLayout(string fileName)
		{
			navBar.SaveLayout(fileName);
		}

		/// <summary>
		/// Saves current visual layout of navigation bar control to XmlElement.
		/// </summary>
		/// <param name="xmlParent">XmlElement object that will act as a parent for the layout definition. Exact same element should be passed into the LoadLayout method to load the layout.</param>
		public void SaveLayout(System.Xml.XmlElement xmlParent)
		{
			navBar.SaveLayout(xmlParent);
		}

		/// <summary>
		/// Gets or sets the navigation bar definition string.
		/// </summary>
		[Browsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public string LayoutDefinition
		{
			get
			{
				return navBar.LayoutDefinition;
			}
			set
			{
				navBar.LayoutDefinition=value;
			}
		}

        /// <summary>
        /// Gets or sets whether anti-alias smoothing is used while painting. Default value is false.
        /// </summary>
        [DefaultValue(false), Browsable(true), Category("Appearance"), Description("Gets or sets whether anti-aliasing is used while painting.")]
        public bool AntiAlias
        {
            get { return navBar.AntiAlias; }
            set
            {
                navBar.AntiAlias = value;
                if (panelTitle != null)
                    panelTitle.AntiAlias = value;
                if (m_PanePopupPanel != null)
                    m_PanePopupPanel.AntiAlias = value;
                if (m_PopupPanelContainer != null)
                    m_PopupPanelContainer.AntiAlias = value;
            }
        }

        /// <summary>
        /// Gets or sets animation time in milliseconds when control is expanded or collapsed. Default value is 100 miliseconds. You can set this to 0 (zero) to disable animation.
        /// </summary>
        [Browsable(true), DefaultValue(100), Category("Expand"), Description("Indicates animation time in milliseconds when control is expanded or collapsed.")]
        public int AnimationTime
        {
            get { return m_AnimationTime; }
            set
            {
                if (m_AnimationTime >= 0)
                    m_AnimationTime = value;
            }
        }

        /// <summary>
        /// Gets or sets whether navigation pane can be collapsed. Default value is false. When set to true
        /// expand/collapse button will be displayed in title so control can be reduced in size.
        /// </summary>
        [Browsable(true), Category("Title"), DefaultValue(false), Description("Indicates whether navigation pane can be collapsed.")]
        public bool CanCollapse
        {
            get { return m_CanCollapse; }
            set
            {
                m_CanCollapse = value;
                OnCanCollapseChanged();
                panelTitle.ExpandButtonVisible = m_CanCollapse;
            }
        }

        /// <summary>
        /// Gets or sets alignment of the expand button inside of title bar.
        /// </summary>
        [Browsable(true), DefaultValue(eTitleButtonAlignment.Right), Category("Title"), Description("Indicates the alignment of expand button inside title bar.")]
        public eTitleButtonAlignment TitleButtonAlignment
        {
            get { return panelTitle.ButtonAlignment; }
            set
            {
                panelTitle.ButtonAlignment = value;
                UpdateExpandButton();
            }
        }

        /// <summary>
        /// Gets or sets whether navigation pane is expanded. Default value is true. 
        /// When control is collapsed it is reduced in size so it consumes less space.
        /// </summary>
        [Browsable(true), Category("Title"), DefaultValue(true), Description("Indicates whether navigation pane can be collapsed.")]
        public bool Expanded
        {
            get { return m_Expanded; }
            set
            {
                if (m_LayoutSuspended)
                {
                    m_ExpandedDelayed = value;
                    return;
                }
                if (m_Expanded != value)
                {
					SetExpanded(value, eEventSource.Code);
                }
            }
        }

		private void SetExpanded(bool expanded, eEventSource source)
		{
			if(ExpandedChanging!=null)
			{
				ExpandedChangeEventArgs args=new ExpandedChangeEventArgs(source, expanded);
				ExpandedChanging(this,args);
				if(args.Cancel)
					return;
			}

			m_Expanded = expanded;
			OnExpandedChanged();

			if(ExpandedChanged!=null)
			{
				ExpandedChangeEventArgs args=new ExpandedChangeEventArgs(source, expanded);
				ExpandedChanged(this,args);
			}
		}

        private void OnExpandedChanged()
        {
            if (m_Expanded)
            {
                foreach (BaseItem item in navBar.Items)
                    item.RenderText = true;
                panelTitle.DrawText = true;
                this.PopupSelectedPaneVisible = false;
                DestroyPanePopup();
                if (this.AnimationTime == 0 || this.DesignMode)
                    TypeDescriptor.GetProperties(this)["Width"].SetValue(this, m_ExpandedSize);
                else
                {
                    Rectangle targetRect = new Rectangle(this.Location, new Size(m_ExpandedSize, this.Height));
                    if (this.Dock == DockStyle.Right)
                        targetRect.Offset(-m_ExpandedSize, 0);
                    BarFunctions.AnimateControl(this, true, m_AnimationTime, this.Bounds, targetRect);
                }
            }
            else
            {
                panelTitle.DrawText = false;
                m_ExpandedSize = this.Width;
                if (this.AnimationTime == 0 || this.DesignMode)
                    TypeDescriptor.GetProperties(this)["Width"].SetValue(this, GetCollapsedSize());
                else
                {
                    Rectangle targetRect = new Rectangle(this.Location, new Size(GetCollapsedSize(), this.Height));
                    if (this.Dock == DockStyle.Right)
                        targetRect.Offset(this.Width - targetRect.Width, 0);
                    BarFunctions.AnimateControl(this, true, m_AnimationTime, this.Bounds, targetRect);
                }
                SetupPanePopup();
                foreach (BaseItem item in navBar.Items)
                    item.RenderText = false;
                navBar.Invalidate();
            }
            this.UpdateExpandButton();
        }

        private int GetCollapsedSize()
        {
            int defaultCollapsedSize = Math.Max(panelTitle.Font.Height + 10, 34);

            if (m_CollapsedSize > 0)
                return m_CollapsedSize;

            ButtonItem item = navBar.ItemsContainer.GetFirstVisibleItem() as ButtonItem;
            if (item == null)
                return defaultCollapsedSize;

            if (item.ImageSize.IsEmpty)
                return defaultCollapsedSize;

            CompositeImage image = item.GetImage(ImageState.Default, Color.Black);
            if (image != null)
                return Math.Max(defaultCollapsedSize, image.RealWidth + 10);

            return defaultCollapsedSize;
        }

        void panelEx1_ExpandedClick(object sender, EventArgs e)
        {
            SetExpanded(!this.Expanded,eEventSource.Mouse);
        }

        private void ApplicationMouseDown(object sender, HandlerMessageEventArgs e)
        {
            if (this.PopupSelectedPaneVisible)
            {
                string s = NativeFunctions.GetClassName(e.hWnd);
                s = s.ToLower();
                if (s.IndexOf("combolbox") >= 0)
                    return;

                Control c = Control.FromChildHandle(e.hWnd);
                while (c != null)
                {
                    if (c == m_PopupPanelContainer || c == m_PanePopupPanel)
                        return;
                    c=c.Parent;
                }
                this.PopupSelectedPaneVisible = false;
            }
        }

        /// <summary>
        /// Gets the reference to the inner panel displaying Navigation Pane vertical text created when control is collapsed.
        /// </summary>
        [Browsable(false)]
        public PanelEx CollapsedInnerPanel
        {
            get
            {
                return m_PanePopupPanel;
            }
        }

        private void SetupPanePopup()
        {
            m_PanePopupPanel = new PanelEx();
            m_PanePopupPanel.ColorSchemeStyle = navBar.Style;
            m_PanePopupPanel.ColorScheme = navBar.GetColorScheme();
            m_PanePopupPanel.ApplyButtonStyle();
            m_PanePopupPanel.Style.VerticalText = true;
            m_PanePopupPanel.Style.ForeColor.ColorSchemePart = eColorSchemePart.PanelText;
            m_PanePopupPanel.Style.BackColor1.ColorSchemePart = eColorSchemePart.PanelBackground;
            m_PanePopupPanel.Style.ResetBackColor2();
            m_PanePopupPanel.StyleMouseOver.VerticalText = true;
            m_PanePopupPanel.StyleMouseDown.VerticalText = true;
            m_PanePopupPanel.Font = panelTitle.Font;
            m_PanePopupPanel.AntiAlias = this.AntiAlias;
            UpdatePanePopupPanelSize();

            if(this.CheckedButton!=null)
                m_PanePopupPanel.Text = this.CheckedButton.Text;
            else
                m_PanePopupPanel.Text = "Navigation Pane";
            
            foreach (Control c in this.Controls)
            {
                if (c is NavigationPanePanel)
                    c.Visible = false;
            }
            this.Controls.Add(m_PanePopupPanel);
            m_PanePopupPanel.Click += new EventHandler(PanePopupPanelClick);
        }

        void PanePopupPanelClick(object sender, EventArgs e)
        {
            this.PopupSelectedPaneVisible = !this.PopupSelectedPaneVisible;
        }

        /// <summary>
        /// Popup selected pane when control is collapsed. When control is collapsed (Expanded=false) currently selected pane is not visible
        /// calling this method will popup selected pane and allow user access to it. Use PopupPaneVisible property
        /// to check whether currently selected pane is displayed as popup.
        /// </summary>
        private void PopupSelectedPane()
        {
            if (m_PopupPaneVisible)
                return;
            Control selectedNavPane = null;
            foreach (Control c in this.Controls)
            {
                if (c is NavigationPanePanel && ((NavigationPanePanel)c).ParentItem == this.CheckedButton)
                {
                    selectedNavPane = c;
                    break;
                }
            }
            if (selectedNavPane == null)
                return;

			// Animation start and end rectangles
			int h = navBar.Top - panelTitle.Bottom;
			Rectangle targetRect = new Rectangle(this.Width, panelTitle.Bottom, m_ExpandedSize, h);
			Rectangle startRect = new Rectangle(this.Width, panelTitle.Bottom, 16, h);

			if(BeforePanelPopup!=null)
			{
				PanelPopupEventArgs args=new PanelPopupEventArgs(targetRect);
				BeforePanelPopup(this, args);
                if(args.Cancel)
					return;
				targetRect=args.PopupBounds;
			}

            Control parentForm = this.FindForm();
            if (parentForm == null)
                parentForm = this.TopLevelControl;
            if (parentForm == null)
                parentForm = this.Parent;

            m_PopupPanelContainer = new PanelEx();
            m_PopupPanelContainer.Visible = false;
            m_PopupPanelContainer.ApplyLabelStyle();
            m_PopupPanelContainer.AntiAlias = this.AntiAlias;
            //m_PopupPanelContainer.Style.BorderSide = eBorderSide.All;
            //m_PopupPanelContainer.Style.Border = eBorderType.SingleLine;
            //m_PopupPanelContainer.Style.BorderWidth = 1;
            //m_PopupPanelContainer.Style.BorderColor.Color = panelTitle.Style.BorderColor.Color;
            //m_PopupPanelContainer.DockPadding.All = 1;
            parentForm.Controls.Add(m_PopupPanelContainer);
            m_PopupPanelContainer.BringToFront();
            this.Controls.Remove(selectedNavPane);
            if (selectedNavPane is NavigationPanePanel)
            {
                NavigationPanePanel panel = ((NavigationPanePanel)selectedNavPane);
                panel.DockPadding.Bottom = 1;
                if (panel.Style.Border == eBorderType.None)
                {
                    m_PopupPanelContainer.Style.BorderSide = eBorderSide.All;
                    m_PopupPanelContainer.Style.Border = eBorderType.SingleLine;
                    m_PopupPanelContainer.Style.BorderWidth = 1;
                    m_PopupPanelContainer.Style.BorderColor.Color = panelTitle.Style.BorderColor.Color;
                    m_PopupPanelContainer.DockPadding.All = 1;
                }
            }
            m_PopupPanelContainer.Controls.Add(selectedNavPane);
            selectedNavPane.Visible = true;

            if (this.Dock == DockStyle.Right)
            {
                targetRect.Offset(-(this.Width + targetRect.Width), 0);
                startRect.Offset(-(this.Width + startRect.Width), 0);
            }

            Point p = this.PointToScreen(targetRect.Location);
            targetRect.Location = parentForm.PointToClient(p);
            p = this.PointToScreen(startRect.Location);
            startRect.Location = parentForm.PointToClient(p);

            if (AnimationTime == 0)
            {
                m_PopupPanelContainer.Bounds = targetRect;
                m_PopupPanelContainer.Visible = true;
            }
            else
                BarFunctions.AnimateControl(m_PopupPanelContainer, true, AnimationTime, startRect, targetRect);

            m_PopupPanelContainer.Focus();
            m_PopupPanelContainer.Leave += new EventHandler(m_PopupPanelContainer_Leave);
            m_PopupPaneVisible = true;

            if (AfterPanelPopup != null)
                AfterPanelPopup(this, new EventArgs());
        }

        void m_PopupPanelContainer_Leave(object sender, EventArgs e)
        {
            if (PopupSelectedPaneVisible)
                PopupSelectedPaneVisible = false;
        }

		private bool m_Hiding=false;
        /// <summary>
        /// Hides popup selected pane when control is collapsed and selected pane is displayed as popup. When control is collapsed (Expanded=false)
        /// currently selected pane can be displayed as popup. Calling this method will hide the popup pane. Use PopupPaneVisible property
        /// to check whether currently selected pane is displayed as popup.
        /// </summary>
        private void HideSelectedPopupPane()
        {
            if (!m_PopupPaneVisible || m_Hiding)
                return;
            m_Hiding=true;
			try
			{
				if (AnimationTime == 0)
					m_PopupPanelContainer.Hide();
				else
				{
					Rectangle targetRect = new Rectangle(this.Width, this.Top, 16, this.Height);
					if (this.Dock == DockStyle.Right)
						targetRect.Offset(-(this.Width + targetRect.Width), 0);
					Point p = this.PointToScreen(targetRect.Location);
					targetRect.Location = m_PopupPanelContainer.Parent.PointToClient(p);
					BarFunctions.AnimateControl(m_PopupPanelContainer, false, AnimationTime, m_PopupPanelContainer.Bounds, targetRect);
				}

				Control navPanel=null;
				foreach(Control c in m_PopupPanelContainer.Controls)
				{
					if(c is NavigationPanePanel)
					{
						c.Visible=false;
						m_PopupPanelContainer.Controls.Remove(c);
						navPanel=c;
						break;
					}
				}
				if(navPanel is NavigationPanePanel)
					((NavigationPanePanel)navPanel).DockPadding.Bottom = 0;
				this.Controls.Add(navPanel);
				m_PopupPanelContainer.Leave -= new EventHandler(m_PopupPanelContainer_Leave);
				m_PopupPanelContainer.Dispose();
				m_PopupPanelContainer = null;
				m_PopupPaneVisible = false;
                OnPanelPopupClosed(EventArgs.Empty);
			}
			finally
			{
				m_Hiding=false;
			}
        }

        /// <summary>
        /// Raises the PanelPopupClosed event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnPanelPopupClosed(EventArgs e)
        {
            EventHandler handler = PanelPopupClosed;
            if (handler != null) handler(this, e);
        }
        /// <summary>
        /// Gets or sets whether selected pane is displayed as popup when control is collapsed (Expanded=false). Using
        /// navigation pane button that is displayed when control is collapsed user can popup or close currently selected pane without
        /// expanding the control. You can use this property to do same from code as well as check whether selected pane is displayed as
        /// popup. Note that control must be collapsed (Expanded=false) in order for this property to have any effect.
        /// </summary>
        [Browsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool PopupSelectedPaneVisible
        {
            get { return m_PopupPaneVisible; }
            set
            {
                if (m_PopupPaneVisible != value)
                {
                    if (value)
                        PopupSelectedPane();
                    else
                        HideSelectedPopupPane();
                }
            }
        }

        private void UpdatePanePopupPanelSize()
        {
            if (m_PanePopupPanel == null)
                return;
            int margin = 3;
            m_PanePopupPanel.Bounds=new Rectangle(new Point(this.ClientRectangle.X + margin, panelTitle.Bottom + margin),
                new Size(this.ClientRectangle.Width - margin * 2, navBar.Top - panelTitle.Bottom - margin * 2));
        }

        private void DestroyPanePopup()
        {
            if (m_PanePopupPanel != null)
            {
                this.Controls.Remove(m_PanePopupPanel);
                m_PanePopupPanel.Dispose();
                m_PanePopupPanel = null;
            }

            foreach(Control c in this.Controls)
            {
                if (c is NavigationPanePanel && ((NavigationPanePanel)c).ParentItem == this.CheckedButton)
                {
                    c.Visible = true;
                    if(this.DesignMode)
                        TypeDescriptor.GetProperties(c)["Visible"].SetValue(c, true);
                    c.BringToFront();
                    break;
                }
            }
        }

        private void OnCanCollapseChanged()
        {
            if (m_CanCollapse)
            {
                UpdateExpandCollapseImages();
            }
            UpdateExpandButton();
        }

        private Image GetCollapseImage(bool mouseOverImage)
        {
            if (mouseOverImage)
            {
                if (m_TitleImageCollapseMouseOver != null)
                    return m_TitleImageCollapseMouseOver;
                return m_DefaultCollapseImageMouseOver;
            }
            else
            {
                if (m_TitleImageCollapse != null)
                    return m_TitleImageCollapse;
                return m_DefaultCollapseImage;
            }
        }

        private Image GetExpandImage(bool mouseOverImage)
        {
            if (mouseOverImage)
            {
                if (m_TitleImageExpandMouseOver != null)
                    return m_TitleImageExpandMouseOver;
                return m_DefaultExpandImageMouseOver;
            }
            else
            {
                if (m_TitleImageExpand != null)
                    return m_TitleImageExpand;
                return m_DefaultExpandImage;
            }
        }

        internal void Office2007ColorTableChanged()
        {
            ColorSchemeStyleChanged();
        }

        private void UpdateExpandButton()
        {
            LocalizationManager lm=new LocalizationManager(navBar as IOwnerLocalize);
            if (m_Expanded)
            {
                if (panelTitle.ButtonAlignment == eTitleButtonAlignment.Right || m_TitleImageCollapse!=null)
                {
                    panelTitle.ExpandChangeButton.Image = GetCollapseImage(false);
                    panelTitle.ExpandChangeButton.HoverImage = GetCollapseImage(true);
                }
                else
                {
                    panelTitle.ExpandChangeButton.Image = GetExpandImage(false);
                    panelTitle.ExpandChangeButton.HoverImage = GetExpandImage(true);
                }
                panelTitle.ExpandChangeButton.Tooltip = lm.GetDefaultLocalizedString(LocalizationKeys.NavPaneCollapseButtonTooltip);
            }
            else
            {
                if (panelTitle.ButtonAlignment == eTitleButtonAlignment.Right || m_TitleImageExpand != null)
                {
                    panelTitle.ExpandChangeButton.Image = GetExpandImage(false);
                    panelTitle.ExpandChangeButton.HoverImage = GetExpandImage(true);
                }
                else
                {
                    panelTitle.ExpandChangeButton.Image = GetCollapseImage(false);
                    panelTitle.ExpandChangeButton.HoverImage = GetCollapseImage(true);
                }
                panelTitle.ExpandChangeButton.Tooltip = lm.GetDefaultLocalizedString(LocalizationKeys.NavPaneExpandButtonTooltip);
            }
            panelTitle.UpdateButtonPosition();
        }
	    
	    private void UpdateExpandCollapseImages()
	    {
            if (m_DefaultCollapseImage != null)
                m_DefaultCollapseImage.Dispose();
            if (m_DefaultExpandImage != null)
                m_DefaultExpandImage.Dispose();
            if (m_DefaultCollapseImageMouseOver != null)
                m_DefaultCollapseImageMouseOver.Dispose();
            if (m_DefaultExpandImageMouseOver != null)
                m_DefaultExpandImageMouseOver.Dispose();

            m_DefaultCollapseImage = UIGraphics.CreateExpandButtonImage(true, panelTitle.ColorScheme.PanelText, false);
            m_DefaultCollapseImageMouseOver = UIGraphics.CreateExpandButtonImage(true, panelTitle.ColorScheme.ItemHotText, false);
            m_DefaultExpandImage = UIGraphics.CreateExpandButtonImage(false, panelTitle.ColorScheme.PanelText, false);
            m_DefaultExpandImageMouseOver = UIGraphics.CreateExpandButtonImage(false, panelTitle.ColorScheme.ItemHotText, false);
	    }

		/// <summary>
		/// Loads navigation bar layout that was saved using SaveLayout method. Note that this method must be called after all items are created and added to the control.
		/// </summary>
		/// <param name="fileName">File to load layout from.</param>
		public void LoadLayout(string fileName)
		{
			navBar.LoadLayout(fileName);
		}

		/// <summary>
		/// Loads navigation bar layout that was saved using SaveLayout method. Note that this method must be called after all items are created and added to the control.
		/// </summary>
		/// <param name="xmlParent">Parent XML element that is used to load layout from. Note that this must be the same element that was passed into the SaveLayout method.</param>
		public void LoadLayout(System.Xml.XmlElement xmlParent)
		{
			navBar.LoadLayout(xmlParent);
		}

        /// <summary>
        /// Gets/Sets the visual style for the control. Default style is Office 2003.
        /// </summary>
        [Browsable(true), DevCoBrowsable(true), Category("Appearance"), Description("Specifies the visual style of the control."), DefaultValue(eDotNetBarStyle.Office2003)]
        public eDotNetBarStyle Style
        {
            get
            {
                return navBar.Style;
            }
            set
            {
                navBar.Style = value;
                ColorSchemeStyleChanged();
            }
        }

        /// <summary>
        /// Called by StyleManager to notify control that style on manager has changed and that control should refresh its appearance if
        /// its style is controlled by StyleManager.
        /// </summary>
        /// <param name="newStyle">New active style.</param>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void StyleManagerStyleChanged(eDotNetBarStyle newStyle)
        {
            ColorSchemeStyleChanged();
            if (this.IsHandleCreated && this.Visible)
                this.Invalidate(true);
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            ColorSchemeStyleChanged();
            base.OnHandleCreated(e);
        }

        /// <summary>
        /// Updates the color scheme on child panels to reflect the style of the NavigationBar control. Calling this method is necessary only if you manually
        /// change the NavigationBar.ColorScheme property.
        /// </summary>
        public void ColorSchemeStyleChanged()
        {
            ColorScheme cs = null;
            eDotNetBarStyle style = navBar.ItemsContainer.EffectiveStyle;

            if (BarFunctions.IsOffice2007Style(style) || navBar.ColorScheme != null && navBar.ColorScheme.PredefinedColorScheme == ePredefinedColorScheme.SystemColors)
                cs = navBar.GetColorScheme();

            foreach (Control c in this.Controls)
            {
                if (c is PanelEx)
                {
                    PanelEx p = c as PanelEx;
                    TypeDescriptor.GetProperties(p)["ColorSchemeStyle"].SetValue(p, style);
                    if (cs != null)
                        ((PanelEx)c).ColorScheme = cs;
                }
            }

            if (style == eDotNetBarStyle.Office2010)
                panelTitle.Style.Border = eBorderType.None;
            else if (BarFunctions.IsOffice2007Style(style))
                panelTitle.Style.Border = eBorderType.RaisedInner;
            else
                panelTitle.Style.Border = eBorderType.SingleLine;

            UpdateExpandCollapseImages();
            UpdateExpandButton();

            if (style == eDotNetBarStyle.Office2010)
            {
                this.DockPadding.All = 0;
                this.navBar.BackgroundStyle.BorderWidth = 0;
                this.navBar.BackgroundStyle.BorderColor.Color = Color.Transparent;
            }
            else
            {
                this.DockPadding.All = 1;
                this.navBar.BackgroundStyle.BorderWidth = 1;
                navBar.BackgroundStyle.BorderColor.ColorSchemePart = eColorSchemePart.PanelBorder;
            }
        }

		#region Event Forwarding
		private void OnNavBarItemClick(object sender, EventArgs e)
		{
			if(ItemClick!=null)
				ItemClick(sender, e);
		}
		private void OnNavBarOptionGroupChanging(object sender, OptionGroupChangingEventArgs e)
		{
			NavigationPanePanel oldPanel=null, newPanel=null;
            if(e.OldChecked!=null)
				oldPanel=this.GetPanel((ButtonItem)e.OldChecked);
			if(e.NewChecked!=null)
                newPanel = this.GetPanel((ButtonItem)e.NewChecked);

			if(newPanel==null)
				return;

			PanelChangingEventArgs epanel=new PanelChangingEventArgs(oldPanel,newPanel);
			InvokePanelChanging(epanel);
			e.Cancel=epanel.Cancel;

		}
		protected virtual void InvokePanelChanging(PanelChangingEventArgs e)
		{
			if(PanelChanging!=null)
				PanelChanging(this,e);
		}
		#endregion

		#region Component Designer generated code
		/// <summary> 
		/// Required method for Designer support - do not modify 
		/// the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent()
		{
			this.panelTitle = new DevComponents.DotNetBar.PanelExTitle();
			this.navBar = new DevComponents.DotNetBar.NavigationBar();
			((ISupportInitialize)this.navBar).BeginInit();
			//this.SuspendLayout();
			// 
			// panelTitle
			// 
			this.panelTitle.Dock = System.Windows.Forms.DockStyle.Top;
			this.panelTitle.Font = new System.Drawing.Font("Tahoma", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0)));
			this.panelTitle.Name = "panelTitle";
			this.panelTitle.Size = new System.Drawing.Size(150, 24);
			this.panelTitle.Style.Alignment = System.Drawing.StringAlignment.Near;
			this.panelTitle.Style.BackColor1.ColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.PanelBackground;
			this.panelTitle.Style.BackColor2.ColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.PanelBackground2;
			this.panelTitle.Style.Border = DevComponents.DotNetBar.eBorderType.SingleLine;
            this.panelTitle.Style.BorderSide = eBorderSide.Bottom;
			this.panelTitle.Style.BorderColor.ColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.PanelBorder;
			this.panelTitle.Style.ForeColor.ColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.PanelText;
			this.panelTitle.Style.GradientAngle = 90;
			this.panelTitle.Style.MarginLeft=4;
			this.panelTitle.StyleMouseDown.Alignment = System.Drawing.StringAlignment.Near;
			this.panelTitle.StyleMouseOver.Alignment = System.Drawing.StringAlignment.Near;
			this.panelTitle.TabIndex = 0;
            this.panelTitle.ExpandButtonVisible = false;
			this.panelTitle.Text = "Title";
			// 
			// navigationBar1
			// 
			this.navBar.BackgroundStyle.BackColor1.ColorSchemePart = eColorSchemePart.PanelBackground;
			this.navBar.BackgroundStyle.Border = DevComponents.DotNetBar.eBorderType.SingleLine;
            this.navBar.BackgroundStyle.BorderSide = eBorderSide.Top;
			this.navBar.BackgroundStyle.BorderColor.ColorSchemePart = eColorSchemePart.PanelBorder;
			this.navBar.Dock = System.Windows.Forms.DockStyle.Bottom;
			this.navBar.Location = new System.Drawing.Point(0, 128);
			this.navBar.Name = "navigationBar1";
			this.navBar.Size = new System.Drawing.Size(150, 32);
			this.navBar.TabIndex = 1;
			this.navBar.Text = "navBar";
			this.navBar.Resize+=new EventHandler(this.OnNavBarResize);
			this.navBar.ItemClick+=new EventHandler(this.OnNavBarItemClick);
			this.navBar.OptionGroupChanging+=new OptionGroupChangingEventHandler(this.OnNavBarOptionGroupChanging);
			this.navBar.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0)));
			// 
			// NavigationPane
			// 
			this.Controls.AddRange(new System.Windows.Forms.Control[] {
																		  this.navBar,
																		  this.panelTitle});
			this.Name = "NavigationPane";
			this.Size = new System.Drawing.Size(150, 192);
            this.DockPadding.All = 1;

			((ISupportInitialize)this.navBar).EndInit();
			//this.ResumeLayout(false);
		}
		#endregion
	}

	#region PanelChangingEventArgs 
	/// <summary>
	/// Represents event arguments for PanelChanging event.
	/// </summary>
	public class PanelChangingEventArgs : EventArgs
	{
		/// <summary>
		/// Set to true to cancel changing of the panel.
		/// </summary>
		public bool Cancel=false;
		/// <summary>
		/// Panel that will be selected if operation is not cancelled.
		/// </summary>
		public readonly NavigationPanePanel NewPanel;
		/// <summary>
		/// Panel that is currently selected and which will be de-selected if operation is not cancelled.
		/// </summary>
		public readonly NavigationPanePanel OldPanel;
		/// <summary>
		/// Default constructor.
		/// </summary>
		public PanelChangingEventArgs(NavigationPanePanel oldpanel, NavigationPanePanel newpanel)
		{
			NewPanel=newpanel;
			OldPanel=oldpanel;
		}
	}
	#endregion

	#region PanelPopupEventArgs
	/// <summary>
	/// Represents event arguments for BeforePanelPopup event.
	/// </summary>
	public class PanelPopupEventArgs : EventArgs
	{
		/// <summary>
		/// Set to true to cancel popup of the panel.
		/// </summary>
		public bool Cancel=false;
		/// <summary>
		/// Size and position of popup. You can modify this memeber to affect size and position of popup.
		/// </summary>
		public Rectangle PopupBounds=Rectangle.Empty;
		/// <summary>
		/// Default constructor.
		/// </summary>
		public PanelPopupEventArgs(Rectangle popupBounds)
		{
			this.PopupBounds=popupBounds;
		}
	}
	#endregion
}