using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using System.ComponentModel;
using System.Collections;
using System.Drawing.Text;

namespace DevComponents.DotNetBar
{
    /// <summary>
    /// Represents graphical panel control with support for different visual styles and gradients.
    /// </summary>
    [ToolboxItem(false), Designer("DevComponents.DotNetBar.Design.PanelControlDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf"), DefaultEvent("Click")]
    public class PanelControl : System.Windows.Forms.Panel, IButtonControl
    {
        #region Private Variables
        private ElementStyle m_Style;
        private ElementStyle m_StyleMouseOver;
        private ElementStyle m_StyleMouseDown;

        private ColorScheme m_ColorScheme = null;
        private eDotNetBarStyle m_ColorSchemeStyle = eDotNetBarStyle.Office2003;

        private bool m_MouseOver = false, m_MouseDown = false;

        private Rectangle m_ClientTextRectangle = Rectangle.Empty;
        private bool m_TextDockConstrained = true;
        private bool m_ShowFocusRectangle;
        //private string m_Text = "";

        // Theme Caching Support
        private ThemeTab m_ThemeTab = null;

        private DialogResult m_DialogResult = DialogResult.None;
        private bool m_IsDefault = false;

        private bool m_AntiAlias = true;
        private Color m_CanvasColor = Color.White;

        protected Bitmap m_ThemeCachedBitmap = null;
        private bool m_SuspendPaint = false;
        private TextMarkup.BodyElement m_TextMarkup = null;
        #endregion

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

        /// <summary>
        ///     Default constructor.
        /// </summary>
        public PanelControl()
        {
            if (!ColorFunctions.ColorsLoaded)
            {
                NativeFunctions.RefreshSettings();
                NativeFunctions.OnDisplayChange();
                ColorFunctions.LoadColors();
            }

            this.SetStyle(ControlStyles.UserPaint, true);
            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            this.SetStyle(ControlStyles.Opaque, true);
            this.SetStyle(ControlStyles.ResizeRedraw, true);
            this.SetStyle(DisplayHelp.DoubleBufferFlag, true);
            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
            this.SetStyle(ControlStyles.ContainerControl, true);

            this.SetStyle(ControlStyles.Selectable, true);
            this.SetStyle(ControlStyles.StandardDoubleClick, false);

            m_ColorScheme = new ColorScheme(m_ColorSchemeStyle);

            ResetStyle();
            ResetStyleMouseOver();
            ResetStyleMouseDown();

            StyleManager.Register(this);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing) StyleManager.Unregister(this);
            base.Dispose(disposing);
        }

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

        internal TextMarkup.BodyElement TextMarkupElement
        {
            get { return m_TextMarkup; }
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public new System.Windows.Forms.BorderStyle BorderStyle
        {
            get { return base.BorderStyle; }
            set { base.BorderStyle = value; }
        }

        /// <summary>
        /// Gets or sets Bar Color Scheme.
        /// </summary>
        [Browsable(false), DevCoBrowsable(false), Category("Appearance"), Description("Gets or sets Bar Color Scheme."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public DevComponents.DotNetBar.ColorScheme ColorScheme
        {
            get { return m_ColorScheme; }
            set
            {
                if (value == null)
                    throw new ArgumentException("NULL is not a valid value for this property.");
                m_ColorScheme = value;
                OnColorSchemeChanged();
                if (this.Visible)
                    this.Invalidate();
            }
        }
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeColorScheme()
        {
            return m_ColorScheme.SchemeChanged;
        }

        internal ColorScheme GetColorScheme()
        {
            if (BarFunctions.IsOffice2007Style(m_ColorSchemeStyle))
            {
                Rendering.Office2007Renderer r = Rendering.GlobalManager.Renderer as Rendering.Office2007Renderer;
                if (r != null && r.ColorTable.LegacyColors != null)
                    return r.ColorTable.LegacyColors;
            }

            return m_ColorScheme;
        }

        private void OnVisualPropertyChanged(object sender, EventArgs e)
        {
            RefreshStyleSystemColors();

            SetRegion();

            this.Invalidate();
        }

        protected override void OnRightToLeftChanged(EventArgs e)
        {
            this.Invalidate();
            base.OnRightToLeftChanged(e);
        }

        private eCornerType m_CurrentCornerType = eCornerType.Square;
        private int m_CornerDiameter = 8;
        /// <summary>
        /// Applies any region related settings from style to control.
        /// </summary>
        protected virtual void SetRegion()
        {
            SetRegion(false);
        }
        private void SetRegion(bool bResize)
        {
            if (!CanSetRegion) return;
            ElementStyle style = GetStyle();
            if (bResize || m_CurrentCornerType != style.CornerType || m_CornerDiameter != style.CornerDiameter)
            {
                m_CurrentCornerType = style.CornerType;
                m_CornerDiameter = style.CornerDiameter;
                if (style != null && !(DrawThemedPane && BarFunctions.ThemedOS) && style.CornerType != eCornerType.Square)
                {
                    this.Region = ElementStyleDisplay.GetStyleRegion(new ElementStyleDisplayInfo(style, null, new Rectangle(0,0,this.Width, this.Height)));
                }
                else
                    this.Region = null;
            }
        }
        internal bool CanSetRegion = true;

        /// <summary>
        /// Applies color scheme colors to the style objects.
        /// </summary>
        public void RefreshStyleSystemColors()
        {
            ColorScheme cs = GetColorScheme();
            if (m_Style != null)
                m_Style.SetColorScheme(cs);
            if (m_StyleMouseOver != null)
                m_StyleMouseOver.SetColorScheme(cs);
            if (m_StyleMouseDown != null)
                m_StyleMouseDown.SetColorScheme(cs);
        }

        protected override void WndProc(ref System.Windows.Forms.Message m)
        {
            const int WM_MOUSEWHEEL = 0x020A;
            const int WM_HSCROLL = 0x0114;
            const int WM_VSCROLL = 0x0115;

            switch (m.Msg)
            {
                case WM_HSCROLL:
                case WM_VSCROLL:
                case WM_MOUSEWHEEL:
                    if (this.Controls.Count == 0)
                    {
                        RefreshTextClientRectangle();
                        this.Invalidate();
                    }
                    else
                    {
                        base.WndProc(ref m);
                        this.Refresh();
                        return;
                    }
                    break;
            }

            base.WndProc(ref m);
        }

        /// <summary>
        /// Creates the Graphics object for the control.
        /// </summary>
        /// <returns>The Graphics object for the control.</returns>
        public new Graphics CreateGraphics()
        {
            Graphics g = base.CreateGraphics();
            if (m_AntiAlias)
            {
                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
#if FRAMEWORK20
                if (!SystemInformation.IsFontSmoothingEnabled)
#endif
                    g.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
            }
            return g;
        }

        protected virtual void BaseWndProc(ref System.Windows.Forms.Message m)
        {
            base.WndProc(ref m);
        }

        /// <summary>
        /// Returns the current style of the control.
        /// </summary>
        /// <returns>Instance of ElementStyle object.</returns>
        protected virtual ElementStyle GetStyle()
        {
            return m_Style;
        }

        /// <summary>
        /// Returns the current mouse down style of the control.
        /// </summary>
        /// <returns>Instance of ElementStyle object.</returns>
        protected virtual ElementStyle GetStyleMouseDown()
        {
            return m_StyleMouseDown;
        }

        /// <summary>
        /// Returns the current mouse over style of the control.
        /// </summary>
        /// <returns>Instance of ElementStyle object.</returns>
        protected virtual ElementStyle GetStyleMouseOver()
        {
            return m_StyleMouseOver;
        }

        /// <summary>
        /// Paints panel using Windows themes.
        /// </summary>
        /// <param name="e">Paint event arguments</param>
        protected virtual void PaintThemed(PaintEventArgs e)
        {
            if (m_ThemeCachedBitmap == null || m_ThemeCachedBitmap.Size != this.ClientRectangle.Size)
            {
                DisposeThemeCachedBitmap();
                Bitmap bmp = new Bitmap(this.ClientRectangle.Width, this.ClientRectangle.Height, e.Graphics);
                Graphics gTmp = Graphics.FromImage(bmp);
                try
                {
                    this.ThemeTab.DrawBackground(gTmp, ThemeTabParts.Pane, ThemeTabStates.Normal, new Rectangle(0, 0, bmp.Width, bmp.Height));
                }
                finally
                {
                    gTmp.Dispose();
                }
                e.Graphics.DrawImage(bmp, 0, 0, bmp.Width, bmp.Height);
                ElementStyle style = GetStyle();
                if (style.BackgroundImage != null)
                    BarFunctions.PaintBackgroundImage(e.Graphics, this.ClientRectangle, style.BackgroundImage, style.BackgroundImagePosition, style.BackgroundImageAlpha);
                m_ThemeCachedBitmap = bmp;
            }
            else
            {
                e.Graphics.DrawImage(m_ThemeCachedBitmap, 0, 0, m_ThemeCachedBitmap.Width, m_ThemeCachedBitmap.Height);
            }
        }

        /// <summary>
        /// Prepares paint surface for paint operation. Called as first thing in Paint event.
        /// </summary>
        /// <param name="e"></param>
        protected virtual void PaintPrepare(PaintEventArgs e)
        {
            using (SolidBrush brush = new SolidBrush(m_CanvasColor))
                e.Graphics.FillRectangle(brush, new Rectangle(0,0,this.Width, this.Height));
            ElementStyle style = GetStyle();
            if ((style.BackColor.IsEmpty || style.BackColor.A < 255) &&
                (style.BackColor2.IsEmpty || style.BackColor2.A < 255))
            {
                base.OnPaintBackground(e);
            }

            if (m_AntiAlias)
            {
                e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                e.Graphics.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
            }
        }

        /// <summary>
        /// Paints panel given current style.
        /// </summary>
        /// <param name="e">Paint event arguments</param>
        protected virtual void PaintStyled(PaintEventArgs e)
        {
            Graphics g = e.Graphics;

            using (ElementStyle style = GetStyle().Copy() as ElementStyle)
            {
                if (m_MouseDown && this.Enabled)
                    style.ApplyStyle(GetStyleMouseDown());
                else if (m_MouseOver && this.Enabled)
                    style.ApplyStyle(GetStyleMouseOver());

                PaintInnerContent(e, style, true);

                if (this.Focused && m_ShowFocusRectangle)
                {
                    Rectangle r = this.ClientRectangle;
                    r.Inflate(-2, -2);
                    if (r.Width > 0 && r.Height > 0)
                        ControlPaint.DrawFocusRectangle(g, r);
                }
            }
        }

        /// <summary>
        /// Paints insides of the control.
        /// </summary>
        /// <param name="e">Paint event arguments.</param>
        protected virtual void PaintInnerContent(PaintEventArgs e, ElementStyle style, bool paintText)
        {
            Graphics g = e.Graphics;
            if (m_TextMarkup == null)
                RefreshTextClientRectangle();
            Rectangle r = new Rectangle(0,0,this.Width, this.Height);
            Rectangle rText = m_ClientTextRectangle;
            //rText.Inflate(-1, -1);

            if (!this.Enabled)
                style.TextColor = GetColorScheme().ItemDisabledText;

            ElementStyleDisplayInfo info = new ElementStyleDisplayInfo(style, g, r);
            info.RightToLeft = (this.RightToLeft == RightToLeft.Yes);
            ElementStyleDisplay.Paint(info);
            
            if (paintText)
            {
                if (m_TextMarkup == null)
                {
                    info.Bounds = rText;
                    ElementStyleDisplay.PaintText(info, this.Text, this.Font);
                }
                else
                {
                    TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, this.Font, style.TextColor, (this.RightToLeft == RightToLeft.Yes), e.ClipRectangle, true);
                    m_TextMarkup.Render(d);
                }
            }

        }

		private bool m_Painting = false;
        protected override void OnPaint(PaintEventArgs e)
        {
            if (m_SuspendPaint || m_Painting) return;
			m_Painting=true;
			try
			{
				SmoothingMode sm = e.Graphics.SmoothingMode;
				TextRenderingHint th = e.Graphics.TextRenderingHint;

				PaintPrepare(e);

				if (DrawThemedPane && BarFunctions.ThemedOS)
				{
					PaintThemed(e);
				}
				else
				{
					PaintStyled(e);
				}

				e.Graphics.SmoothingMode = sm;
				e.Graphics.TextRenderingHint = th;

				base.OnPaint(e);
			}
			finally
			{
				m_Painting=false;
			}
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            RefreshTextClientRectangle();
            SetRegion(true);
        }

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

        protected override void NotifyInvalidate(Rectangle invalidatedArea)
        {
            base.NotifyInvalidate(invalidatedArea);
            SetRegion(true);
        }

        //protected override void OnEnabledChanged(EventArgs e)
        //{
        //    m_SuspendPaint = true;
        //    base.OnEnabledChanged(e);
        //    m_SuspendPaint = false;
        //}

        protected override void OnChangeUICues(UICuesEventArgs e)
        {
            if (m_ShowFocusRectangle)
            {
                if (e.ChangeFocus)
                    this.Invalidate();
            }
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (m_TextMarkup != null)
                m_TextMarkup.MouseMove(this, e);
            base.OnMouseMove(e);
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (m_TextMarkup != null)
                m_TextMarkup.MouseDown(this, e);

            if (e.Button == MouseButtons.Left)
            {
                if (!m_MouseDown)
                {
                    m_MouseDown = true;
                    if (GetStyleMouseDown().Custom)
                        this.Invalidate(false);
                }
            }
            base.OnMouseDown(e);
        }

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

            base.OnMouseUp(e);

            if (m_MouseDown)
            {
                m_MouseDown = false;
                if (GetStyleMouseDown().Custom)
                    this.Invalidate(false);
            }
        }

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

        protected override void OnMouseEnter(EventArgs e)
        {
            base.OnMouseEnter(e);

            if (!m_MouseOver)
            {
                m_MouseOver = true;
                if (GetStyleMouseOver().Custom)
                    this.Invalidate(false);
            }
        }

        protected override void OnMouseLeave(EventArgs e)
        {
            if (m_TextMarkup != null)
                m_TextMarkup.MouseLeave(this);

            base.OnMouseLeave(e);

            if (m_MouseOver)
            {
                m_MouseOver = false;
                if (GetStyleMouseOver().Custom)
                    this.Invalidate(false);
            }
        }

        protected override void OnFontChanged(EventArgs e)
        {
            base.OnFontChanged(e);
            if (m_TextMarkup != null)
                m_TextMarkup.InvalidateElementsSize();
            RefreshTextClientRectangle();
        }

        protected override void OnTextChanged(EventArgs e)
        {
            string text = this.Text;

            if (m_TextMarkup != null)
            {
                m_TextMarkup.MouseLeave(this);
                m_TextMarkup.HyperLinkClick -= new EventHandler(TextMarkupLinkClicked);
                m_TextMarkup = null;
            }

            if (TextMarkup.MarkupParser.IsMarkup(ref text))
                m_TextMarkup = TextMarkup.MarkupParser.Parse(text);

            if (m_TextMarkup != null)
            {
                m_TextMarkup.HyperLinkClick += new EventHandler(TextMarkupLinkClicked);
                RefreshTextClientRectangle();
            }
            this.Invalidate();
            base.OnTextChanged(e);
        }

        private void TextMarkupLinkClicked(object sender, EventArgs e)
        {
            TextMarkup.HyperLink link = sender as TextMarkup.HyperLink;
            if (link != null)
            {
                OnMarkupLinkClick(new MarkupLinkClickEventArgs(link.Name, link.HRef));
            }
        }

        protected virtual void OnMarkupLinkClick(MarkupLinkClickEventArgs e)
        {
            if (this.MarkupLinkClick != null)
                MarkupLinkClick(this, e);
        }

        protected virtual void ResizeMarkup()
        {
            if (m_TextMarkup != null)
            {
                Rectangle r = this.ClientTextRectangle;
                r.Inflate(-2, 0);
                r.X += ElementStyleLayout.LeftWhiteSpace(this.Style);
                r.Width -= ElementStyleLayout.HorizontalStyleWhiteSpace(this.Style);
                r.Y += ElementStyleLayout.TopWhiteSpace(this.Style);
                r.Height -= ElementStyleLayout.VerticalStyleWhiteSpace(this.Style);
                
                if (r.Width <= 0 || r.Height <= 0)
                    return;
                Graphics g = this.CreateGraphics();
                try
                {
                    if (m_AntiAlias)
                    {
                        g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                        g.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
                    }
                    TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, this.Font, SystemColors.Control, (this.RightToLeft == RightToLeft.Yes));
                    m_TextMarkup.Measure(r.Size, d);
                    m_TextMarkup.Arrange(r, d);
                    if (this.AutoScroll)
                    {
                        Size autoScrollMinSize = Size.Empty;
                        if (m_TextMarkup.Bounds.Height > r.Height)
                            autoScrollMinSize.Height = m_TextMarkup.Bounds.Height + m_Style.MarginTop + m_Style.MarginBottom + 2;
                        if (m_TextMarkup.Bounds.Width > r.Width)
                            autoScrollMinSize.Width = m_TextMarkup.Bounds.Width + m_Style.MarginLeft + m_Style.MarginRight + 2;

                        if (this.AutoScrollMinSize != autoScrollMinSize)
                            this.AutoScrollMinSize = autoScrollMinSize;
                    }
                    else if (!this.AutoScrollMinSize.IsEmpty)
                        this.AutoScrollMinSize = Size.Empty;
                }
                finally
                {
                    g.Dispose();
                }
            }
        }

        protected override void OnSystemColorsChanged(EventArgs e)
        {
            base.OnSystemColorsChanged(e);

            Application.DoEvents();

            m_ColorScheme.Refresh(null, true);
            RefreshStyleSystemColors();

            if (m_ThemeTab != null)
                RefreshThemes();

            this.Invalidate(true);
        }

        protected override void OnHandleDestroyed(EventArgs e)
        {
            DisposeThemes();
            base.OnHandleDestroyed(e);
        }

        protected override bool ProcessMnemonic(char charCode)
        {
            if (IsMnemonic(charCode, this.Text))
            {
                OnClick(new EventArgs());
                return true;
            }
            return base.ProcessMnemonic(charCode);
        }

        ///// <summary>
        /////   Gets or sets the text displayed on panel.
        ///// </summary>
        //[Browsable(true), DevCoBrowsable(true), EditorBrowsable(EditorBrowsableState.Always), Category("Appearance"), Description("Gets or sets the text displayed on panel.")]
        //public override string Text
        //{
        //    get { return m_Text; }
        //    set
        //    {
        //        if (value.Length < 0) return;
        //        base.Text = value;
        //        m_Text = value;
        //        OnTextChanged(new EventArgs());
        //        this.Invalidate();
        //    }
        //}

        /// <summary>
        /// Gets or sets whether focus rectangle is displayed when control has focus.
        /// </summary>
        [Browsable(true), DevCoBrowsable(true), DefaultValue(false), Category("Appearance"), Description("Indicates whether focus rectangle is displayed when control has focus.")]
        public bool ShowFocusRectangle
        {
            get { return m_ShowFocusRectangle; }
            set
            {
                m_ShowFocusRectangle = value;
                if (this.DesignMode)
                    this.Invalidate();
            }
        }

        /// <summary>
        /// Gets or sets the canvas color for the panel. Canvas color will be visible on areas of the control that do not get covered
        /// by the style and it will also be used as a base color for style to be painted on.
        /// </summary>
        [Browsable(true), Category("Background"), Description("Gets or sets the canvas color.")]
        public Color CanvasColor
        {
            get
            {
                return m_CanvasColor;
            }
            set
            {
                m_CanvasColor = value;
                if (this.DesignMode)
                    this.Invalidate();
            }
        }
        /// <summary>
        /// Indicates whether CanvasColor should be serialized. Used by windows forms designer design-time support.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeCanvasColor()
        { return (m_CanvasColor != Color.White); }
        /// <summary>
        /// Resets CanvasColor to it's default value. Used by windows forms designer design-time support.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetCanvasColor()
        {
            m_CanvasColor = Color.White;
        }

        /// <summary>
        /// Gets or sets the panel style.
        /// </summary>
        [Browsable(true), DevCoBrowsable(true), Category("Style"), Description("Indicates panel style."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public virtual ElementStyle Style
        {
            get { return m_Style; }
            //set
            //{
            //    if (value == null)
            //        throw new InvalidOperationException("Null is not valid value for this property");
            //    m_Style = value; 
            //}
        }
        /// <summary>
        ///     Resets the style to it's default value.
        /// </summary>
        public void ResetStyle()
        {
			if(m_Style==null)
			{
				// Set default style
				m_Style = new ElementStyle();
                m_Style.SetColorScheme(GetColorScheme());
				m_Style.StyleChanged += new EventHandler(this.OnVisualPropertyChanged);
			}
			else
				m_Style.Reset();

            RefreshStyleSystemColors();
            this.Invalidate();
        }

        /// <summary>
        /// Resets the internal mouse tracking properties that track whether mouse is over the panel and whether is mouse pressed while over the panel.
        /// </summary>
        public void ResetMouseTracking()
        {
            m_MouseOver = false;
            m_MouseDown = false;
            this.Invalidate();
        }

        /// <summary>
        /// Gets or sets the panel style when mouse hovers over the panel.
        /// </summary>
        [Browsable(true), DevCoBrowsable(true), NotifyParentPropertyAttribute(true), Category("Style"), Description("Gets or sets the panel style when mouse hovers over the panel."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public virtual ElementStyle StyleMouseOver
        {
            get
            {
                return m_StyleMouseOver;
            }
            //set
            //{
            //    if (value == null)
            //        throw new InvalidOperationException("Null is not valid value for this property.");
            //    m_StyleMouseOver = value;
            //}
        }
        /// <summary>
        ///     Resets the style to it's default value.
        /// </summary>
        public void ResetStyleMouseOver()
        {
			if(m_StyleMouseOver==null)
			{
				m_StyleMouseOver = new ElementStyle();
                m_StyleMouseOver.SetColorScheme(GetColorScheme());
				m_StyleMouseOver.StyleChanged += new EventHandler(this.OnVisualPropertyChanged);
			}
			else
				m_StyleMouseOver.Reset();
            this.Invalidate();
        }

        /// <summary>
        /// Gets or sets the panel style when mouse button is pressed on the panel.
        /// </summary>
        [Browsable(true), DevCoBrowsable(true), NotifyParentPropertyAttribute(true), Category("Style"), Description("Gets or sets the panel style when mouse button is pressed on the panel."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public virtual ElementStyle StyleMouseDown
        {
            get
            {
                return m_StyleMouseDown;
            }
            //set
            //{
            //    if (value == null)
            //        throw new InvalidOperationException("Null is not valid value for this property.");
            //    m_StyleMouseDown = value;
            //}
        }
        /// <summary>
        ///     Resets the style to it's default value.
        /// </summary>
        public void ResetStyleMouseDown()
        {
			if(m_StyleMouseDown==null)
			{
				m_StyleMouseDown = new ElementStyle();
                m_StyleMouseDown.SetColorScheme(GetColorScheme());
				m_StyleMouseDown.StyleChanged += new EventHandler(this.OnVisualPropertyChanged);
			}
			else
				m_StyleMouseDown.Reset();
            this.Invalidate();
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override Color BackColor
        {
            get { return base.BackColor; }
            set { base.BackColor = value; }
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override Image BackgroundImage
        {
            get { return base.BackgroundImage; }
            set { base.BackgroundImage = value; }
        }
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override ImageLayout BackgroundImageLayout
        {
            get { return base.BackgroundImageLayout; }
            set { base.BackgroundImageLayout = value; }
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override Color ForeColor
        {
            get { return base.ForeColor; }
            set { base.ForeColor = value; }
        }

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

        internal eDotNetBarStyle EffectiveColorSchemeStyle
        {
            get
            {
                if (m_ColorSchemeStyle == eDotNetBarStyle.StyleManagerControlled)
                    return StyleManager.GetEffectiveStyle();
                return m_ColorSchemeStyle;
            }
        }
        /// <summary>
        ///     Gets or sets color scheme style.
        /// </summary>
        [Browsable(true), DevCoBrowsable(true), Category("Style"), Description("Gets or sets color scheme style."), DefaultValue(eDotNetBarStyle.Office2003)]
        public eDotNetBarStyle ColorSchemeStyle
        {
            get { return m_ColorSchemeStyle; }
            set
            {
                m_ColorSchemeStyle = value;
                m_ColorScheme = new ColorScheme(EffectiveColorSchemeStyle);
                OnColorSchemeChanged();
                this.Invalidate();
            }
        }

        /// <summary>
        /// Called after either ColorScheme or ColorSchemeStyle has changed. If you override make sure that you call base implementation so default
        /// processing can occur.
        /// </summary>
        protected virtual void OnColorSchemeChanged()
        {
            RefreshStyleSystemColors();
        }

        protected virtual void RefreshTextClientRectangle()
        {
            Rectangle r = this.DisplayRectangle;
            if (!m_TextDockConstrained)
                return;

            foreach (Control ctrl in this.Controls)
            {
                if (ctrl.Dock != DockStyle.None)
                {
                    if (ctrl.Dock == DockStyle.Fill)
                    {
                        r = Rectangle.Empty;
                        break;
                    }
                    switch (ctrl.Dock)
                    {
                        case DockStyle.Left:
                            {
                                r.X += ctrl.Width;
                                r.Width -= ctrl.Width;
                                break;
                            }
                        case DockStyle.Right:
                            {
                                r.Width -= ctrl.Width;
                                break;
                            }
                        case DockStyle.Top:
                            {
                                r.Y += ctrl.Height;
                                r.Height -= ctrl.Height;
                                break;
                            }
                        case DockStyle.Bottom:
                            {
                                r.Height -= ctrl.Height;
                                break;
                            }
                    }
                }
            }
            if (r.Width <= 0 || r.Height <= 0)
                r = Rectangle.Empty;
            m_ClientTextRectangle = r;

            ResizeMarkup();
        }

        [Browsable(true), DefaultValue(""), DesignerSerializationVisibility(DesignerSerializationVisibility.Visible),  EditorBrowsable(EditorBrowsableState.Always), Bindable(true)]
        public override string Text
        {
            get
            {
                return base.Text;
            }
            set
            {
                base.Text = value;
            }
        }

        /// <summary>
        /// Gets or sets whether text rectangle painted on panel is considering docked controls inside the panel. 
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates whether text rectangle painted on panel is considering docked controls inside the panel.")]
        public virtual bool TextDockConstrained
        {
            get { return m_TextDockConstrained; }
            set
            {
                m_TextDockConstrained = value;
                if (this.DesignMode)
                    this.Invalidate();
            }

        }

        protected override void OnControlAdded(ControlEventArgs e)
        {
            base.OnControlAdded(e);
            if (this.DesignMode)
            {
                this.Invalidate();
            }
        }
        protected override void OnControlRemoved(ControlEventArgs e)
        {
            base.OnControlRemoved(e);
            if (m_TextDockConstrained && this.DesignMode)
            {
                this.Invalidate();
            }
        }

        /// <summary>
        /// Gets or sets the text rectangle. This property is set by internal implementation and it should not be set by outside code.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle ClientTextRectangle
        {
            get { return m_ClientTextRectangle; }
            set { m_ClientTextRectangle = value; }
        }

        /// <summary>
        ///     Applies predefined Panel color scheme to the control.
        /// </summary>
        public void ApplyPanelStyle()
        {
            ApplyPanelStyle(eDotNetBarStyle.Office2003);
        }

        /// <summary>
        ///     Applies predefined Panel color scheme to the control.
        /// </summary>
        public void ApplyPanelStyle(eDotNetBarStyle style)
        {
            this.ColorSchemeStyle = style;

            this.ResetStyle();
            this.ResetStyleMouseDown();
            this.ResetStyleMouseOver();

            m_Style.Border = eStyleBorderType.Solid;
            m_Style.BorderWidth = 1;
            m_Style.BorderColorSchemePart = eColorSchemePart.PanelBorder;
            m_Style.BackColorSchemePart = eColorSchemePart.PanelBackground;
            m_Style.BackColor2SchemePart = eColorSchemePart.PanelBackground2;
            m_Style.BackColorGradientAngle = GetColorScheme().PanelBackgroundGradientAngle;
            m_Style.TextColorSchemePart = eColorSchemePart.PanelText;
            m_Style.TextAlignment = eStyleTextAlignment.Center;
            m_Style.TextLineAlignment = eStyleTextAlignment.Center;

            this.Invalidate();
        }

        /// <summary>
        ///     Applies predefined Button color scheme to the control.
        /// </summary>
        public void ApplyButtonStyle()
        {
            this.ColorSchemeStyle = eDotNetBarStyle.Office2003;

            this.ResetStyle();
            this.ResetStyleMouseDown();
            this.ResetStyleMouseOver();

            this.Style.TextAlignment = eStyleTextAlignment.Center;
            this.Style.TextLineAlignment = eStyleTextAlignment.Center;
            this.Style.BackColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.BarBackground;
            this.Style.BackColor2SchemePart = DevComponents.DotNetBar.eColorSchemePart.BarBackground2;
            this.Style.BackgroundImagePosition = DevComponents.DotNetBar.eStyleBackgroundImage.Tile;
            this.Style.Border = eStyleBorderType.Solid;
            this.Style.BorderWidth = 1;
            this.Style.BorderColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.BarDockedBorder;
            this.Style.TextColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemText;
            this.Style.BackColorGradientAngle = 90;
            this.StyleMouseDown.BackColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemPressedBackground;
            this.StyleMouseDown.BackColor2SchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemPressedBackground2;
            this.StyleMouseDown.BorderColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemPressedBorder;
            this.StyleMouseDown.TextColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemPressedText;
            this.StyleMouseOver.BackColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemHotBackground;
            this.StyleMouseOver.BackColor2SchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemHotBackground2;
            this.StyleMouseOver.BorderColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemHotBorder;
            this.StyleMouseOver.TextColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.ItemHotText;

            this.Invalidate();
        }

        /// <summary>
        ///     Applies predefined Label color scheme to the control.
        /// </summary>
        public void ApplyLabelStyle()
        {
            this.ResetStyleMouseDown();
            this.ResetStyleMouseOver();

            ApplyLabelStyle(this.Style);
            this.Invalidate();
        }

        /// <summary>
        /// Applies predefined lable style to the ElementStyle object.
        /// </summary>
        /// <param name="style">Reference to ElementStyle object.</param>
        protected virtual void ApplyLabelStyle(ElementStyle style)
        {
            style.Reset();
            style.TextAlignment = eStyleTextAlignment.Center;
            style.BackColorSchemePart = DevComponents.DotNetBar.eColorSchemePart.BarBackground;
            style.BackColor2SchemePart = DevComponents.DotNetBar.eColorSchemePart.BarBackground2;
            style.BackgroundImagePosition = DevComponents.DotNetBar.eStyleBackgroundImage.Tile;
            style.BorderColorSchemePart = eColorSchemePart.BarDockedBorder;
            style.BorderWidth = 1;
            style.TextColorSchemePart = eColorSchemePart.ItemText;
            style.BackColorGradientAngle = 90;

        }
        /// <summary>
        /// Gets or sets whether painting of the control is suspended.
        /// </summary>
        protected virtual bool SuspendPaint
        {
            get { return m_SuspendPaint; }
            set { m_SuspendPaint = value; }
        }

        #region IButtonControl implementation
        /// <summary>
        /// Gets or sets the value returned to the parent form when the button is clicked.
        /// </summary>
        [Browsable(true), Category("Behavior"), DefaultValue(DialogResult.None), Description("Gets or sets the value returned to the parent form when the button is clicked.")]
        public DialogResult DialogResult
        {
            get
            {
                return m_DialogResult;
            }

            set
            {
                if (Enum.IsDefined(typeof(DialogResult), value))
                {
                    m_DialogResult = value;
                }
            }
        }

        /// <summary>
        /// Notifies a control that it is the default button so that its appearance and behavior is adjusted accordingly.
        /// </summary>
        /// <param name="value">true if the control should behave as a default button; otherwise false.</param>
        public void NotifyDefault(bool value)
        {
            if (m_IsDefault != value)
            {
                m_IsDefault = value;
            }
        }

        /// <summary>
        /// Generates a Click event for the control.
        /// </summary>
        public void PerformClick()
        {
            if (this.CanSelect)
            {
                this.OnClick(EventArgs.Empty);
            }
        }
        #endregion

        #region Themes Support
        /// <summary>
        /// Specifies whether item is drawn using Themes when running on OS that supports themes like Windows XP.
        /// </summary>
        [System.ComponentModel.Browsable(true), DevCoBrowsable(true), System.ComponentModel.DefaultValue(false), System.ComponentModel.Category("Appearance"), System.ComponentModel.Description("Specifies whether item is drawn using Themes when running on OS that supports themes like Windows XP.")]
        public virtual bool ThemeAware
        {
            get
            {
                return DrawThemedPane;
            }
            set
            {
                DisposeThemeCachedBitmap();
                DrawThemedPane = value;
                this.Invalidate();
            }
        }

        internal bool DrawThemedPane = false;
        private void RefreshThemes()
        {
            DisposeThemeCachedBitmap();
            if (m_ThemeTab != null)
            {
                m_ThemeTab.Dispose();
                m_ThemeTab = new ThemeTab(this);
            }
        }
        private void DisposeThemes()
        {
            if (m_ThemeTab != null)
            {
                m_ThemeTab.Dispose();
                m_ThemeTab = null;
            }
            DisposeThemeCachedBitmap();
        }
        protected void DisposeThemeCachedBitmap()
        {
            if (m_ThemeCachedBitmap != null)
            {
                m_ThemeCachedBitmap.Dispose();
                m_ThemeCachedBitmap = null;
            }
        }
        internal DevComponents.DotNetBar.ThemeTab ThemeTab
        {
            get
            {
                if (m_ThemeTab == null)
                    m_ThemeTab = new ThemeTab(this);
                return m_ThemeTab;
            }
        }
        #endregion
    }
}