using System;
using System.Text;
using System.Windows.Forms;
using System.ComponentModel;
using DevComponents.DotNetBar.Rendering;
using System.Drawing;
using DevComponents.DotNetBar.TextMarkup;
using System.Reflection;
using DevComponents.Editors;
using System.Collections;

namespace DevComponents.DotNetBar.Controls
{
    [ToolboxBitmap(typeof(TextBoxX), "Controls.TextBoxX.ico"), ToolboxItem(true), Designer("DevComponents.DotNetBar.Design.TextBoxXDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf")]
    public class TextBoxX : TextBox, INonClientControl
#if FRAMEWORK20
, IInputButtonControl
#endif
    {
        #region Private Variables
        private NonClientPaintHandler m_NCPainter = null;
        private string m_WatermarkText = "";
        private bool m_Focused = false;
        private Font m_WatermarkFont = null;
        private Color m_WatermarkColor = SystemColors.GrayText;
        private ElementStyle m_BorderStyle = null;
        private IntPtr m_LastFocusWindow;
        private string m_OriginalText;
        private bool m_IsTextBoxItem = false;
        private Color m_FocusHighlightColor = ColorScheme.GetColor(0xFFFF88);
        private bool m_FocusHighlightEnabled = false;
        private Color m_LastBackColor = Color.Empty;
        #endregion

        #region Events
#if FRAMEWORK20
        /// <summary>
        /// Occurs when ButtonCustom control is clicked.
        /// </summary>
        public event EventHandler ButtonCustomClick;

        /// <summary>
        /// Occurs when ButtonCustom2 control is clicked.
        /// </summary>
        public event EventHandler ButtonCustom2Click;
#endif
        #endregion

        #region Constructor
        public TextBoxX()
        {
#if FRAMEWORK20
            _ButtonCustom = new InputButtonSettings(this);
            _ButtonCustom2 = new InputButtonSettings(this);
            CreateButtonGroup();
#endif

            m_BorderStyle = new ElementStyle();
            m_BorderStyle.StyleChanged += new EventHandler(BorderStyle_StyleChanged);
            m_NCPainter = new NonClientPaintHandler(this, eScrollBarSkin.Optimized);
            base.BorderStyle = BorderStyle.None;
            this.AutoSize = false;
            StyleManager.Register(this);
        }

        /// <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)
        {
            // Metro needs BackColor and ForeColor set
            if (StyleManager.IsMetro(newStyle) || StyleManager.IsMetro(StyleManager.PreviousStyle) && !StyleManager.IsMetro(newStyle))
                StyleManager.UpdateAmbientColors(this);
            UpdateEnabledBackColor();
        }

        internal TextBoxX(bool isTextBoxItem)
            : this()
        {
            m_IsTextBoxItem = isTextBoxItem;
        }

        protected override void Dispose(bool disposing)
        {
            if (m_NCPainter != null)
            {
                m_NCPainter.Dispose();
                //m_NCPainter = null;
            }
            if (m_BorderStyle != null) m_BorderStyle.StyleChanged -= new EventHandler(BorderStyle_StyleChanged);
            StyleManager.Unregister(this);
            base.Dispose(disposing);
        }
        #endregion

        #region Windows Messages Handling
        private bool m_IgnoreFocus = false;
        private bool _MouseOverButtons = false;
        protected override void WndProc(ref Message m)
        {
            if (this.IsDisposed)
            {
                base.WndProc(ref m);
                return;
            }
            if (m_NCPainter != null)
            {
                bool callBase = m_NCPainter.WndProc(ref m);

                if (callBase)
                    base.WndProc(ref m);
            }
            else
            {
                base.WndProc(ref m);
            }

#if FRAMEWORK20
            if (RenderButtons)
            {
                switch (m.Msg)
                {
                    case (int)WinApi.WindowsMessages.WM_NCMOUSEMOVE:
                    case (int)WinApi.WindowsMessages.WM_NCHITTEST:
                        {
                            Point p = PointToClient(new Point(WinApi.LOWORD(m.LParam), WinApi.HIWORD(m.LParam)));
                            if (_ButtonGroup.RenderBounds.Contains(p))
                            {
                                m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.ClientArea);
                                return;
                            }
                            break;
                        }
                }
            }
#endif

            switch (m.Msg)
            {
                case (int)WinApi.WindowsMessages.WM_SETFOCUS:
                    {
                        if (m_IgnoreFocus)
                        {
                            m_IgnoreFocus = false;
                        }
                        else
                        {
                            m_Focused = true;
                            m_LastFocusWindow = m.WParam;
                            m_OriginalText = this.Text;
                            if (this.FocusHighlightEnabled && this.Enabled)
                            {
                                m_LastBackColor = this.BackColor;
                                this.BackColor = this.FocusHighlightColor;
                                this.InvalidateNonClient();
                            }
                        }
                        break;
                    }
                case (int)WinApi.WindowsMessages.WM_KILLFOCUS:
                    {
                        if (!m_Focused)
                        {
                            m_IgnoreFocus = true;
                        }
                        else
                        {
                            m_Focused = false;
                            if (this.Text.Length == 0)
                                this.Invalidate();
                            if (this.FocusHighlightEnabled && !m_LastBackColor.IsEmpty)
                            {
                                this.BackColor = m_LastBackColor;
                                this.InvalidateNonClient();
                            }
                        }
                        break;
                    }
                case (int)WinApi.WindowsMessages.WM_PAINT:
                    {
                        if (RenderWatermark)
                            DrawWatermark();
                        if (this.Parent is ItemControl)
                            ((ItemControl)this.Parent).UpdateKeyTipsCanvas();
                        break;
                    }
            }
        }

        private bool RenderWatermark
        {
            get
            {
                if (!_WatermarkEnabled)
                    return false;
                if (_WatermarkBehavior == eWatermarkBehavior.HideOnFocus)
                    return !m_Focused && this.Enabled && this.Text != null && this.Text.Length == 0 && (m_WatermarkText.Length > 0 || _WatermarkImage != null);
                else
                    return this.Enabled && this.Text != null && this.Text.Length == 0 && (m_WatermarkText.Length > 0 || _WatermarkImage != null);
            }
        }
        #endregion

        #region Internal Implementation

        private bool _IsEnterInputKey = false;
        /// <summary>
        /// Indicates whether internal override for IsInputKey returns true for the Enter key.
        /// </summary>
        [DefaultValue(false), Category("Behavior"), Description("Indicates whether internal override for IsInputKey returns true for the Enter key.")]
        public bool IsEnterInputKey
        {
            get { return _IsEnterInputKey; }
            set { _IsEnterInputKey = value; }
        }

        protected override bool IsInputKey(Keys keyData)
        {
            if (keyData == Keys.Enter && _IsEnterInputKey)
                return true;
            return base.IsInputKey(keyData);
        }

        private bool _AutoSelectAll = false;
        /// <summary>
        /// Indicates whether all text is auto-selected when control gets input focus. Default value is false.
        /// </summary>
        [DefaultValue(false), Category("Behavior"), Description("Indicates whether all text is auto-selected when control gets input focus.")]
        public bool AutoSelectAll
        {
            get { return _AutoSelectAll; }
            set { _AutoSelectAll = value; }
        }
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            _ButtonGroup.ProcessKeyPress(e);
            if (!this.Multiline && _PreventEnterBeep && e.KeyChar == (char)Keys.Enter)
            {
                e.Handled = true;
            }
            base.OnKeyPress(e);
        }

        private bool _PreventEnterBeep = false;
        /// <summary>
        /// Gets or sets whether control prevents Beep sound when Enter key is pressed.
        /// </summary>
        [DefaultValue(false), Category("Behavior"), Description("Gets or sets whether control prevents Beep sound when Enter key is pressed.")]
        public bool PreventEnterBeep
        {
            get { return _PreventEnterBeep; }
            set
            {
                _PreventEnterBeep = value;
            }
        }

        /// <summary>
        /// Gets or sets whether FocusHighlightColor is used as background color to highlight text box when it has input focus. Default value is false.
        /// </summary>
        [DefaultValue(false), Browsable(true), Category("Appearance"), Description("Indicates whether FocusHighlightColor is used as background color to highlight text box when it has input focus.")]
        public bool FocusHighlightEnabled
        {
            get { return m_FocusHighlightEnabled; }
            set
            {
                if (m_FocusHighlightEnabled != value)
                {
                    m_FocusHighlightEnabled = value;
                    if (this.Focused)
                        this.Invalidate();
                    if (!m_FocusHighlightEnabled)
                        this.ResetBackColor();
                }
            }
        }

        /// <summary>
        /// Gets or sets the color used as background color to highlight text box when it has input focus and focus highlight is enabled.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Indicates color used as background color to highlight text box when it has input focus and focus highlight is enabled.")]
        public Color FocusHighlightColor
        {
            get { return m_FocusHighlightColor; }
            set
            {
                if (m_FocusHighlightColor != value)
                {
                    m_FocusHighlightColor = value;
                    if (this.Focused)
                        this.Invalidate();
                }
            }
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeFocusHighlightColor()
        {
            return !m_FocusHighlightColor.Equals(ColorScheme.GetColor(0xFFFF88));
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetFocusHighlightColor()
        {
            FocusHighlightColor = ColorScheme.GetColor(0xFFFF88);
        }

        internal void ReleaseFocus()
        {
            if (this.Focused && m_LastFocusWindow != IntPtr.Zero)
            {
                IntPtr focus = m_LastFocusWindow;
                m_LastFocusWindow = IntPtr.Zero;
                Control ctrl = Control.FromChildHandle(focus);
                if (ctrl != this)
                {
                    Control p = this.Parent;
                    while (p != null)
                    {
                        if (p == ctrl)
                        {
                            if (ctrl is MenuPanel)
                                ctrl.Focus();
                            return;
                        }
                        p = p.Parent;
                    }

                    if (ctrl != null)
                        ctrl.Focus();
                    else
                    {
                        NativeFunctions.SetFocus(focus);
                    }
                }
            }
        }

        protected override void OnKeyUp(KeyEventArgs e)
        {
            _ButtonGroup.ProcessKeyUp(e);
            base.OnKeyUp(e);
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            _ButtonGroup.ProcessKeyDown(e);

            base.OnKeyDown(e);
            if (m_IsTextBoxItem)
            {
                /*if (e.KeyCode == Keys.Enter)
                    ReleaseFocus();
                else*/
                if (!e.Handled && e.KeyCode == Keys.Escape)
                {
                    this.Text = m_OriginalText;
                    this.SelectionStart = 0;
                    ReleaseFocus();
                }
            }
        }

        /// <summary>
        /// Occurs during preprocessing to handle command keys. Command keys are keys that always take precedence over regular input keys. Examples of command keys include accelerators and menu shortcuts. Set Handled=true to indicate that you handled the key and that it should not be passed for further processing.
        /// </summary>
        [Description("Occurs during preprocessing to handle command keys. Command keys are keys that always take precedence over regular input keys. Examples of command keys include accelerators and menu shortcuts. Set Handled=true to indicate that you handled the key and that it should not be passed for further processing.")]
        public event KeyEventHandler CommandKeyDown;
        /// <summary>
        /// Raises CommandKeyDown event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnCommandKeyDown(KeyEventArgs e)
        {
            KeyEventHandler handler = CommandKeyDown;
            if (handler != null)
                handler(this, e);
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            if ((keyData & Keys.A) == Keys.A && Control.ModifierKeys == Keys.ControlKey)
            {
                this.SelectAll();
                return true;
            }
            if (_ButtonGroup.ProcessCmdKey(ref msg, keyData))
                return true;
            if (CommandKeyDown != null)
            {
                KeyEventArgs args = new KeyEventArgs(keyData);
                OnCommandKeyDown(args);
                if (args.Handled) return true;
            }
            return base.ProcessCmdKey(ref msg, keyData);
        }

        protected override void OnGotFocus(EventArgs e)
        {
            if (_AutoSelectAll)
                this.SelectAll();
            base.OnGotFocus(e);
        }

        protected override void OnLostFocus(EventArgs e)
        {
            m_LastFocusWindow = IntPtr.Zero;
            base.OnLostFocus(e);
        }

        /// <summary>
        /// Gets or sets the scrollbar skinning type when control is using Office 2007 style.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public eScrollBarSkin ScrollbarSkin
        {
            get { return m_NCPainter.SkinScrollbars; }
            set { m_NCPainter.SkinScrollbars = value; }
        }

        /// <summary>
        /// Specifies the control border style. Default value has Class property set so the system style for the control is used.
        /// </summary>
        [Browsable(true), Category("Style"), Description("Specifies the control border style. Default value has Class property set so the system style for the control is used."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ElementStyle Border
        {
            get { return m_BorderStyle; }
        }

        private void BorderStyle_StyleChanged(object sender, EventArgs e)
        {
            InvalidateNonClient();
        }

        protected override void OnReadOnlyChanged(EventArgs e)
        {
            InvalidateNonClient();
            base.OnReadOnlyChanged(e);
        }

        /// <summary>
        /// Invalidates non-client area of the text box as response to the border changes.
        /// </summary>
        public void InvalidateNonClient()
        {
            if (!BarFunctions.IsHandleValid(this)) return;
            NativeFunctions.SetWindowPos(this.Handle, IntPtr.Zero, 0, 0, 0, 0, NativeFunctions.SWP_FRAMECHANGED |
                                NativeFunctions.SWP_NOACTIVATE | NativeFunctions.SWP_NOMOVE | NativeFunctions.SWP_NOSIZE | NativeFunctions.SWP_NOZORDER);
            SetAutoHeight();
            const int RDW_INVALIDATE = 0x0001;
            const int RDW_FRAME = 0x0400;
            NativeFunctions.RECT r = new NativeFunctions.RECT(0, 0, this.Width, this.Height);
            NativeFunctions.RedrawWindow(this.Handle, ref r, IntPtr.Zero, RDW_INVALIDATE | RDW_FRAME);
        }

        private TextMarkup.BodyElement m_TextMarkup = null;
        private void MarkupTextChanged()
        {
            m_TextMarkup = null;

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

            m_TextMarkup = TextMarkup.MarkupParser.Parse(m_WatermarkText);
            ResizeMarkup();
        }

        private void ResizeMarkup()
        {
            if (m_TextMarkup != null)
            {
                using (Graphics g = this.CreateGraphics())
                {
                    MarkupDrawContext dc = GetMarkupDrawContext(g);
                    m_TextMarkup.Measure(GetWatermarkBounds().Size, dc);
                    Size sz = m_TextMarkup.Bounds.Size;
                    m_TextMarkup.Arrange(new Rectangle(GetWatermarkBounds().Location, sz), dc);
                }
            }
        }

        private Rectangle GetWatermarkBounds()
        {
            Rectangle r = this.ClientRectangle;
            r.Inflate(-1, 0);
            return r;
        }

        private void DrawWatermark()
        {
            using (Graphics g = this.CreateGraphics())
            {
                Rectangle bounds = GetWatermarkBounds();
                if (_WatermarkImage != null)
                {
                    Rectangle imageBounds = new Rectangle(Point.Empty, _WatermarkImage.Size);
                    if (_WatermarkImageAlignment == ContentAlignment.BottomCenter)
                        imageBounds.Location = new Point(bounds.X + (bounds.Width - imageBounds.Width) / 2, bounds.Bottom - imageBounds.Height);
                    else if (_WatermarkImageAlignment == ContentAlignment.BottomLeft)
                        imageBounds.Location = new Point(bounds.X, bounds.Bottom - imageBounds.Height);
                    else if (_WatermarkImageAlignment == ContentAlignment.BottomRight)
                        imageBounds.Location = new Point(bounds.Right - imageBounds.Width, bounds.Bottom - imageBounds.Height);
                    else if (_WatermarkImageAlignment == ContentAlignment.MiddleCenter)
                        imageBounds.Location = new Point(bounds.X + (bounds.Width - imageBounds.Width) / 2, bounds.Y + (bounds.Height - imageBounds.Height) / 2);
                    else if (_WatermarkImageAlignment == ContentAlignment.MiddleLeft)
                        imageBounds.Location = new Point(bounds.X, bounds.Y + (bounds.Height - imageBounds.Height) / 2);
                    else if (_WatermarkImageAlignment == ContentAlignment.MiddleRight)
                        imageBounds.Location = new Point(bounds.Right - imageBounds.Width, bounds.Y + (bounds.Height - imageBounds.Height) / 2);
                    else if (_WatermarkImageAlignment == ContentAlignment.TopCenter)
                        imageBounds.Location = new Point(bounds.X + (bounds.Width - imageBounds.Width) / 2, bounds.Y);
                    else if (_WatermarkImageAlignment == ContentAlignment.TopLeft)
                        imageBounds.Location = new Point(bounds.X, bounds.Y);
                    else if (_WatermarkImageAlignment == ContentAlignment.TopRight)
                        imageBounds.Location = new Point(bounds.Right - imageBounds.Width, bounds.Y);
                    g.DrawImage(_WatermarkImage, imageBounds);

                    if (_WatermarkImageAlignment == ContentAlignment.BottomLeft || _WatermarkImageAlignment == ContentAlignment.MiddleLeft || _WatermarkImageAlignment == ContentAlignment.TopLeft)
                    {
                        bounds.X = imageBounds.Right;
                        bounds.Width = Math.Max(0, bounds.Width - imageBounds.Width);
                    }
                    else if (_WatermarkImageAlignment == ContentAlignment.BottomRight || _WatermarkImageAlignment == ContentAlignment.MiddleRight || _WatermarkImageAlignment == ContentAlignment.TopRight)
                    {
                        bounds.Width = Math.Max(0, bounds.Width - imageBounds.Width);
                    }
                }

                if (bounds.Width <= 0) return;

                if (m_TextMarkup != null)
                {
                    MarkupDrawContext dc = GetMarkupDrawContext(g);
                    m_TextMarkup.Render(dc);
                }
                else
                {
                    eTextFormat tf = eTextFormat.Left;
                    if (this.Multiline)
                    {
                        if (this.TextAlign == HorizontalAlignment.Center)
                            tf |= eTextFormat.VerticalCenter;
                        else if (TextAlign == HorizontalAlignment.Right)
                            tf |= eTextFormat.Bottom;
                    }

                    if (this.RightToLeft == RightToLeft.Yes) tf |= eTextFormat.RightToLeft;
                    if (this.TextAlign == HorizontalAlignment.Left)
                        tf |= eTextFormat.Left;
                    else if (this.TextAlign == HorizontalAlignment.Right)
                        tf |= eTextFormat.Right;
                    else if (this.TextAlign == HorizontalAlignment.Center)
                        tf |= eTextFormat.HorizontalCenter;
                    tf |= eTextFormat.EndEllipsis;
                    tf |= eTextFormat.WordBreak;
                    TextDrawing.DrawString(g, m_WatermarkText, (m_WatermarkFont == null ? this.Font : m_WatermarkFont),
                        m_WatermarkColor, bounds, tf);
                }
            }
        }

        protected override void OnFontChanged(EventArgs e)
        {
            SetAutoHeight();
            base.OnFontChanged(e);
        }
        /// <summary>
        /// Calculates and sets the text-box height based on font and style. This method is used internally and should not be used.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void SetAutoHeight()
        {
            if (!this.AutoSize && this.Multiline == false && this.BorderStyle == BorderStyle.None && !this.IsDisposed && this.Parent != null && !m_IsTextBoxItem)
            {
                int h = this.FontHeight;
                if (this.Font != null) h = Math.Max(h, this.Font.Height);
                h++;
                // Adjust for DPI other than 96
                //using (Graphics graphics = Graphics.FromHwnd(IntPtr.Zero))
                //{
                //    if (graphics.DpiX != 96f)
                //    {
                //        h = (int)Math.Ceiling(h * (graphics.DpiX / 96f));
                //    }
                //}
                bool disposeStyle = false;
                ElementStyle style = GetBorderStyle(out disposeStyle);
                if (style != null)
                {
                    if (style.PaintTopBorder)
                    {
                        if (style.CornerType == eCornerType.Rounded || style.CornerType == eCornerType.Diagonal)
                            h += Math.Max(style.BorderTopWidth, style.CornerDiameter / 2 + 1);
                        else
                            h += style.BorderTopWidth;
                    }

                    if (style.PaintBottomBorder)
                    {
                        if (style.CornerType == eCornerType.Rounded || style.CornerType == eCornerType.Diagonal)
                            h += Math.Max(style.BorderBottomWidth, style.CornerDiameter / 2 + 1);
                        else
                            h += style.BorderBottomWidth;
                    }
                    h += style.PaddingTop + style.PaddingBottom;
                    if (disposeStyle) style.Dispose();
                }
#if (FRAMEWORK20)
                if (_ButtonCustom != null && _ButtonCustom.Visible && _ButtonCustom.Image != null)
                {
                    h = Math.Max(h, _ButtonCustom.Image.Height + 6);
                }
                if (_ButtonCustom2 != null && _ButtonCustom2.Visible && _ButtonCustom2.Image != null)
                {
                    h = Math.Max(h, _ButtonCustom2.Image.Height + 6);
                }
#endif
                this.Height = h;
            }
        }

        protected override void OnResize(EventArgs e)
        {
            ResizeMarkup();
#if (FRAMEWORK20)
            _ButtonGroup.InvalidateArrange();
#endif
            base.OnResize(e);
        }

        private MarkupDrawContext GetMarkupDrawContext(Graphics g)
        {
            return new MarkupDrawContext(g, (m_WatermarkFont == null ? this.Font : m_WatermarkFont), m_WatermarkColor, this.RightToLeft == RightToLeft.Yes);
        }

        protected override void OnTextAlignChanged(EventArgs e)
        {
            if (m_WatermarkText.Length > 0)
                this.Invalidate();
            base.OnTextAlignChanged(e);
        }

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

        private Color _EnabledBackColor = Color.Empty;
        protected override void OnEnabledChanged(EventArgs e)
        {
            if (m_WatermarkText.Length > 0)
                this.Invalidate();
            UpdateEnabledBackColor();
            base.OnEnabledChanged(e);
        }

        private void UpdateEnabledBackColor()
        {
            if (!_DisabledBackColor.IsEmpty)
            {
                if (!this.Enabled)
                {
                    _EnabledBackColor = this.BackColor;
                    this.BackColor = _DisabledBackColor;
                }
                else if (!_EnabledBackColor.IsEmpty)
                {
                    this.BackColor = _EnabledBackColor;
                    _EnabledBackColor = Color.Empty;
                }
            }
        }

        protected override void OnTextChanged(EventArgs e)
        {
            if (m_WatermarkText.Length > 0)
                this.Invalidate();
            base.OnTextChanged(e);
        }

        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public new BorderStyle BorderStyle
        {
            get { return base.BorderStyle; }
            set { }
        }

        private Rendering.BaseRenderer m_DefaultRenderer = null;
        private Rendering.BaseRenderer m_Renderer = null;
        private eRenderMode m_RenderMode = eRenderMode.Global;
        /// <summary>
        /// Returns the renderer control will be rendered with.
        /// </summary>
        /// <returns>The current renderer.</returns>
        public virtual Rendering.BaseRenderer GetRenderer()
        {
            if (m_RenderMode == eRenderMode.Global && Rendering.GlobalManager.Renderer != null)
                return Rendering.GlobalManager.Renderer;
            else if (m_RenderMode == eRenderMode.Custom && m_Renderer != null)
                return m_Renderer;

            if (m_DefaultRenderer == null)
                m_DefaultRenderer = new Rendering.Office2007Renderer();

            return m_DefaultRenderer;
        }

        /// <summary>
        /// Gets or sets the rendering mode used by control. Default value is eRenderMode.Global which means that static GlobalManager.Renderer is used. If set to Custom then Renderer property must
        /// also be set to the custom renderer that will be used.
        /// </summary>
        [Browsable(false), DefaultValue(eRenderMode.Global)]
        public eRenderMode RenderMode
        {
            get { return m_RenderMode; }
            set
            {
                if (m_RenderMode != value)
                {
                    m_RenderMode = value;
                    this.Invalidate(true);
                }
            }
        }

        /// <summary>
        /// Gets or sets the custom renderer used by the items on this control. RenderMode property must also be set to eRenderMode.Custom in order renderer
        /// specified here to be used.
        /// </summary>
        [Browsable(false), DefaultValue(null)]
        public DevComponents.DotNetBar.Rendering.BaseRenderer Renderer
        {
            get
            {
                return m_Renderer;
            }
            set { m_Renderer = value; }
        }

        private bool _WatermarkEnabled = true;
        /// <summary>
        /// Gets or sets whether watermark text is displayed when control is empty. Default value is true.
        /// </summary>
        [DefaultValue(true), Description("Indicates whether watermark text is displayed when control is empty.")]
        public virtual bool WatermarkEnabled
        {
            get { return _WatermarkEnabled; }
            set { _WatermarkEnabled = value; this.Invalidate(); }
        }

        private Image _WatermarkImage = null;
        /// <summary>
        /// Gets or sets the watermark image displayed inside of the control when Text is not set and control does not have input focus.
        /// </summary>
        [DefaultValue(null), Category("Appearance"), Description("Indicates watermark image displayed inside of the control when Text is not set and control does not have input focus.")]
        public Image WatermarkImage
        {
            get { return _WatermarkImage; }
            set { _WatermarkImage = value; this.Invalidate(); }
        }
        private ContentAlignment _WatermarkImageAlignment = ContentAlignment.MiddleLeft;
        /// <summary>
        /// Gets or sets the watermark image alignment.
        /// </summary>
        [DefaultValue(ContentAlignment.MiddleLeft), Category("Appearance"), Description("Indicates watermark image alignment.")]
        public ContentAlignment WatermarkImageAlignment
        {
            get { return _WatermarkImageAlignment; }
            set { _WatermarkImageAlignment = value; this.Invalidate(); }
        }

        /// <summary>
        /// Gets or sets the watermark (tip) text displayed inside of the control when Text is not set and control does not have input focus. This property supports text-markup.
        /// </summary>
        [Browsable(true), DefaultValue(""), Localizable(true), Category("Appearance"), Description("Indicates watermark text displayed inside of the control when Text is not set and control does not have input focus."), Editor("DevComponents.DotNetBar.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor))]
        public string WatermarkText
        {
            get { return m_WatermarkText; }
            set
            {
                if (value == null) value = "";
                m_WatermarkText = value;
                MarkupTextChanged();
                this.Invalidate();
            }
        }

        /// <summary>
        /// Gets or sets the watermark font.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Indicates watermark font."), DefaultValue(null)]
        public Font WatermarkFont
        {
            get { return m_WatermarkFont; }
            set { m_WatermarkFont = value; this.Invalidate(); }
        }

        /// <summary>
        /// Gets or sets the watermark text color.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Indicates watermark text color.")]
        public Color WatermarkColor
        {
            get { return m_WatermarkColor; }
            set { m_WatermarkColor = value; this.Invalidate(); }
        }
        /// <summary>
        /// Indicates whether property should be serialized by Windows Forms designer.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeWatermarkColor()
        {
            return m_WatermarkColor != SystemColors.GrayText;
        }
        /// <summary>
        /// Resets the property to default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetWatermarkColor()
        {
            this.WatermarkColor = SystemColors.GrayText;
        }

        private eWatermarkBehavior _WatermarkBehavior = eWatermarkBehavior.HideOnFocus;
        /// <summary>
        /// Gets or sets the watermark hiding behaviour. Default value indicates that watermark is hidden when control receives input focus.
        /// </summary>
        [DefaultValue(eWatermarkBehavior.HideOnFocus), Category("Behavior"), Description("Indicates watermark hiding behaviour.")]
        public eWatermarkBehavior WatermarkBehavior
        {
            get { return _WatermarkBehavior; }
            set { _WatermarkBehavior = value; this.Invalidate(); }
        }

        private ElementStyle GetBorderStyle(out bool disposeStyle)
        {
            disposeStyle = false;
            m_BorderStyle.SetColorScheme(this.GetColorScheme());
            return ElementStyleDisplay.GetElementStyle(m_BorderStyle, out disposeStyle);
        }

#if FRAMEWORK20
        private InputButtonSettings _ButtonCustom = null;
        /// <summary>
        /// Gets the object that describes the settings for the custom button that can execute an custom action of your choosing when clicked.
        /// </summary>
        [Category("Buttons"), Description("Describes the settings for the custom button that can execute an custom action of your choosing when clicked."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public InputButtonSettings ButtonCustom
        {
            get
            {
                return _ButtonCustom;
            }
        }

        private InputButtonSettings _ButtonCustom2 = null;
        /// <summary>
        /// Gets the object that describes the settings for the custom button that can execute an custom action of your choosing when clicked.
        /// </summary>
        [Category("Buttons"), Description("Describes the settings for the custom button that can execute an custom action of your choosing when clicked."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public InputButtonSettings ButtonCustom2
        {
            get
            {
                return _ButtonCustom2;
            }
        }


        void IInputButtonControl.InputButtonSettingsChanged(InputButtonSettings inputButtonSettings)
        {
            OnInputButtonSettingsChanged(inputButtonSettings);
        }

        protected virtual void OnInputButtonSettingsChanged(InputButtonSettings inputButtonSettings)
        {
            UpdateButtons();
        }

        private VisualGroup _ButtonGroup = null;
        private void UpdateButtons()
        {
            RecreateButtons();
            _ButtonGroup.InvalidateArrange();
            this.InvalidateNonClient();
        }

        protected virtual void RecreateButtons()
        {
            VisualItem[] buttons = CreateOrderedButtonList();
            // Remove all system buttons that are already in the list
            VisualGroup group = _ButtonGroup;
            VisualItem[] items = new VisualItem[group.Items.Count];
            group.Items.CopyTo(items);
            foreach (VisualItem item in items)
            {
                if (item.ItemType == eSystemItemType.SystemButton)
                {
                    group.Items.Remove(item);
                    if (item == _ButtonCustom.ItemReference)
                        item.MouseUp -= new MouseEventHandler(CustomButtonClick);
                    else if (item == _ButtonCustom2.ItemReference)
                        item.MouseUp -= new MouseEventHandler(CustomButton2Click);
                }
            }

            // Add new buttons to the list
            group.Items.AddRange(buttons);
        }

        private void CustomButtonClick(object sender, MouseEventArgs e)
        {
            if (_ButtonCustom.ItemReference.RenderBounds.Contains(e.X, e.Y))
                OnButtonCustomClick(e);
        }

        /// <summary>
        /// Invokes ButtonCustomClick event.
        /// </summary>
        public void PerformButtonCustomClick()
        {
            OnButtonCustomClick(EventArgs.Empty);
        }

        protected virtual void OnButtonCustomClick(EventArgs e)
        {
            if (ButtonCustomClick != null)
                ButtonCustomClick(this, e);
        }

        private void CustomButton2Click(object sender, MouseEventArgs e)
        {
            if (_ButtonCustom2.ItemReference.RenderBounds.Contains(e.X, e.Y))
                OnButtonCustom2Click(e);
        }

        /// <summary>
        /// Invokes ButtonCustomClick2 event.
        /// </summary>
        public void PerformButtonCustom2Click()
        {
            OnButtonCustom2Click(EventArgs.Empty);
        }

        protected virtual void OnButtonCustom2Click(EventArgs e)
        {
            if (ButtonCustom2Click != null)
                ButtonCustom2Click(this, e);
        }

        private VisualItem[] CreateOrderedButtonList()
        {
            SortedList list = CreateSortedButtonList();

            VisualItem[] items = new VisualItem[list.Count];
            list.Values.CopyTo(items, 0);

            return items;
        }

        private void CustomButtonKeyClick(object sender, EventArgs e)
        {
            if (e is KeyEventArgs)
                OnButtonCustomClick(e);
        }
        private void CustomButton2KeyClick(object sender, EventArgs e)
        {
            if (e is KeyEventArgs)
                OnButtonCustom2Click(e);
        }
        protected virtual SortedList CreateSortedButtonList()
        {
            SortedList list = new SortedList(4);
            if (_ButtonCustom.Visible)
            {
                VisualItem button = CreateButton(_ButtonCustom);
                if (_ButtonCustom.ItemReference != null)
                {
                    _ButtonCustom.ItemReference.MouseUp -= CustomButtonClick;
                    _ButtonCustom.ItemReference.Click -= CustomButtonKeyClick;
                }
                _ButtonCustom.ItemReference = button;
                button.Click += CustomButtonKeyClick;
                button.MouseUp += new MouseEventHandler(CustomButtonClick);
                button.Enabled = _ButtonCustom.Enabled;
                list.Add(_ButtonCustom, button);
            }

            if (_ButtonCustom2.Visible)
            {
                VisualItem button = CreateButton(_ButtonCustom2);
                if (_ButtonCustom2.ItemReference != null)
                {
                    _ButtonCustom2.ItemReference.MouseUp -= CustomButton2Click;
                    _ButtonCustom2.ItemReference.Click -= CustomButton2KeyClick;
                }
                _ButtonCustom2.ItemReference = button;
                button.Click += CustomButton2KeyClick;
                button.MouseUp += new MouseEventHandler(CustomButton2Click);
                button.Enabled = _ButtonCustom2.Enabled;
                list.Add(_ButtonCustom2, button);
            }

            return list;
        }

        protected virtual VisualItem CreateButton(InputButtonSettings buttonSettings)
        {
            VisualCustomButton button = new VisualCustomButton();
            ApplyButtonSettings(buttonSettings, button);
            return button;
        }

        protected virtual void ApplyButtonSettings(InputButtonSettings buttonSettings, VisualButton button)
        {
            button.Text = buttonSettings.Text;
            button.Image = buttonSettings.Image;
            button.ItemType = eSystemItemType.SystemButton;
            button.Enabled = buttonSettings.Enabled;
            button.Shortcut = buttonSettings.Shortcut;
            button.Tooltip = buttonSettings.Tooltip;
            button.Symbol = buttonSettings.Symbol;
            button.SymbolSet = buttonSettings.SymbolSet;
            button.SymbolColor = buttonSettings.SymbolColor;
            button.Checked = buttonSettings.Checked;
        }

        private void CreateButtonGroup()
        {
            VisualGroup group = new VisualGroup();
            group.HorizontalItemSpacing = 0;
            group.ArrangeInvalid += ButtonGroupArrangeInvalid;
            group.RenderInvalid += ButtonGroupRenderInvalid;
            group.ResetMouseHover += ButtonGroupResetMouseHover;
            _ButtonGroup = group;
        }

        private void ButtonGroupRenderInvalid(object sender, EventArgs e)
        {
            InvalidateNonClient();
        }

        private void ButtonGroupArrangeInvalid(object sender, EventArgs e)
        {
            InvalidateNonClient();
        }

        private void ButtonGroupResetMouseHover(object sender, EventArgs e)
        {
            DevComponents.AdvTree.Interop.WinApi.ResetHover(this);
        }

        private bool _MouseOver = false;
        private PaintInfo CreatePaintInfo(Graphics g)
        {
            PaintInfo p = new PaintInfo();
            p.Graphics = g;
            p.DefaultFont = this.Font;
            p.ForeColor = this.ForeColor;
            p.RenderOffset = new System.Drawing.Point();
            Size s = this.Size;
            bool disposeStyle = false;
            ElementStyle style = GetBorderStyle(out disposeStyle);
            s.Height -= (ElementStyleLayout.TopWhiteSpace(style, eSpacePart.Border) + ElementStyleLayout.BottomWhiteSpace(style, eSpacePart.Border)) + 2;
            s.Width -= (ElementStyleLayout.LeftWhiteSpace(style, eSpacePart.Border) + ElementStyleLayout.RightWhiteSpace(style, eSpacePart.Border)) + 2;
            p.AvailableSize = s;
            p.ParentEnabled = this.Enabled;
            p.MouseOver = _MouseOver || this.Focused;
            if (disposeStyle) style.Dispose();
            return p;
        }

        private bool RenderButtons
        {
            get
            {
                return (this.ScrollBars == ScrollBars.None) && (_ButtonCustom != null && _ButtonCustom.Visible || _ButtonCustom2 != null && _ButtonCustom2.Visible);
            }
        }

        private void PaintButtons(Graphics g)
        {
            PaintInfo p = CreatePaintInfo(g);
            if (!_ButtonGroup.IsLayoutValid)
            {
                _ButtonGroup.PerformLayout(p);
            }
            bool disposeStyle = false;
            ElementStyle style = GetBorderStyle(out disposeStyle);
            //p.RenderOffset = new Point(this.Width - ElementStyleLayout.RightWhiteSpace(style, eSpacePart.Border) - _ButtonGroup.Size.Width, ElementStyleLayout.TopWhiteSpace(style, eSpacePart.Border));
            _ButtonGroup.RenderBounds = new Rectangle(this.Width - (ElementStyleLayout.RightWhiteSpace(style, eSpacePart.Border) + 1) - _ButtonGroup.Size.Width, ElementStyleLayout.TopWhiteSpace(style, eSpacePart.Border) + 1,
                _ButtonGroup.Size.Width, _ButtonGroup.Size.Height);
            _ButtonGroup.ProcessPaint(p);
            if (disposeStyle) style.Dispose();
        }

        private Cursor _ControlCursor = null;
        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (RenderButtons)
            {
                _ButtonGroup.ProcessMouseMove(e);
                if (_ButtonGroup.RenderBounds.Contains(e.X, e.Y))
                {
                    if (_ControlCursor == null)
                    {
                        _InternalCursorChange = true;
                        _ControlCursor = this.Cursor;
                        this.Cursor = Cursors.Arrow;
                        _InternalCursorChange = false;
                    }
                }
                else if (_ControlCursor != null)
                {
                    _InternalCursorChange = true;
                    this.Cursor = _ControlCursor;
                    _ControlCursor = null;
                    _InternalCursorChange = false;
                }
            }
            base.OnMouseMove(e);
        }
        protected override void OnMouseEnter(EventArgs e)
        {
            _MouseOver = true;
            base.OnMouseEnter(e);
        }
        protected override void OnMouseLeave(EventArgs e)
        {
            _MouseOver = false;
            if (RenderButtons)
            {
                _ButtonGroup.ProcessMouseLeave();
                if (_ControlCursor != null)
                {
                    _InternalCursorChange = true;
                    this.Cursor = _ControlCursor;
                    _ControlCursor = null;
                    _InternalCursorChange = false;
                }
            }
            base.OnMouseLeave(e);
        }
        private bool _InternalCursorChange = false;
        protected override void OnCursorChanged(EventArgs e)
        {
            if (_ControlCursor != null && !_InternalCursorChange)
                _ControlCursor = this.Cursor;
            base.OnCursorChanged(e);
        }
        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (RenderButtons)
                _ButtonGroup.ProcessMouseDown(e);
            base.OnMouseDown(e);
        }
        protected override void OnMouseUp(MouseEventArgs e)
        {
            if (RenderButtons)
                _ButtonGroup.ProcessMouseUp(e);
            base.OnMouseUp(e);
        }
        protected override void OnMouseHover(EventArgs e)
        {
            if (RenderButtons)
                _ButtonGroup.ProcessMouseHover(e);
            base.OnMouseHover(e);
        }
#endif
        #endregion

        #region INonClientControl Members
        void INonClientControl.BaseWndProc(ref Message m)
        {
            base.WndProc(ref m);
        }

        //CreateParams INonClientControl.ControlCreateParams
        //{
        //    get { return base.CreateParams; }
        //}

        ItemPaintArgs INonClientControl.GetItemPaintArgs(System.Drawing.Graphics g)
        {
            ItemPaintArgs pa = new ItemPaintArgs(this as IOwner, this, g, GetColorScheme());
            pa.Renderer = this.GetRenderer();
            pa.DesignerSelection = false; // m_DesignerSelection;
            pa.GlassEnabled = !this.DesignMode && WinApi.IsGlassEnabled;
            return pa;
        }

        ElementStyle INonClientControl.BorderStyle
        {
            get { bool disposeStyle = false; return GetBorderStyle(out disposeStyle); }
        }

        void INonClientControl.PaintBackground(PaintEventArgs e)
        {
            if (this.Parent == null) return;
            Type t = typeof(Control);
            MethodInfo mi = t.GetMethod("PaintTransparentBackground", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(PaintEventArgs), typeof(Rectangle) }, null);
            if (mi != null)
            {
                mi.Invoke(this, new object[] { e, new Rectangle(0, 0, this.Width, this.Height) });
            }
        }

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

        IntPtr INonClientControl.Handle
        {
            get { return this.Handle; }
        }

        int INonClientControl.Width
        {
            get { return this.Width; }
        }

        int INonClientControl.Height
        {
            get { return this.Height; }
        }

        bool INonClientControl.IsHandleCreated
        {
            get { return this.IsHandleCreated; }
        }

        Point INonClientControl.PointToScreen(Point client)
        {
            return this.PointToScreen(client);
        }

        Color INonClientControl.BackColor
        {
            get { return this.BackColor; }
        }

        void INonClientControl.AdjustClientRectangle(ref Rectangle r)
        {
#if FRAMEWORK20
            if (RenderButtons)
            {
                if (!_ButtonGroup.IsLayoutValid)
                {
                    using (Graphics g = this.CreateGraphics())
                    {
                        PaintInfo p = CreatePaintInfo(g);
                        _ButtonGroup.PerformLayout(p);
                    }
                }
                r.Width -= _ButtonGroup.Size.Width + 1;
            }
#endif
        }

        void INonClientControl.AdjustBorderRectangle(ref Rectangle r) { }

        void INonClientControl.RenderNonClient(Graphics g)
        {
#if FRAMEWORK20
            if (RenderButtons)
                PaintButtons(g);
#endif
        }

        private Color _DisabledBackColor = Color.Empty;
        /// <summary>
        /// Specifies back color when Enabled=false
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Specifies back color when Enabled=false")]
        public Color DisabledBackColor
        {
            get { return _DisabledBackColor; }
            set
            {
                _DisabledBackColor = value;
                if (!Enabled) this.Invalidate();
            }
        }
        public bool ShouldSerializeDisabledBackColor()
        {
            return !_DisabledBackColor.IsEmpty;
        }
        public void ResetDisabledBackColor()
        {
            DisabledBackColor = Color.Empty;
        }
        #endregion
    }
}